@prosopo/provider 4.15.14 → 4.15.16

package/dist/cjs/tasks/frictionless/frictionlessTasks.cjs

@@ -1,488 +1,350 @@
-"use strict";
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const types = require("@prosopo/types");
-const uuid = require("uuid");
-const dnsEventUrl = require("../../api/dnsEventUrl.cjs");
-const lang = require("../../rules/lang.cjs");
-const usageCounters = require("../../util/usageCounters.cjs");
-const captchaManager = require("../captchaManager.cjs");
-const decisionMachineRunner = require("../decisionMachine/decisionMachineRunner.cjs");
-const getBotScore = require("../detection/getBotScore.cjs");
-const routingMachine = require("./routingMachine.cjs");
-const DEFAULT_MAX_TIMESTAMP_AGE = 60 * 10 * 1e3;
-const getSessionIDPrefix = (host) => {
-  return host ? host.replace(".prosopo.io", "") : "local";
+const require_usageCounters = require("../../util/usageCounters.cjs");
+const require_decisionMachineRunner = require("../decisionMachine/decisionMachineRunner.cjs");
+const require_dnsEventUrl = require("../../api/dnsEventUrl.cjs");
+const require_lang = require("../../rules/lang.cjs");
+const require_captchaManager = require("../captchaManager.cjs");
+const require_getBotScore = require("../detection/getBotScore.cjs");
+const require_routingMachine = require("./routingMachine.cjs");
+let _prosopo_types = require("@prosopo/types");
+let uuid = require("uuid");
+//#region src/tasks/frictionless/frictionlessTasks.ts
+var DEFAULT_MAX_TIMESTAMP_AGE = 600 * 1e3;
+var getSessionIDPrefix = (host) => {
+	return host ? host.replace(".prosopo.io", "") : "local";
 };
-class FrictionlessManager extends captchaManager.CaptchaManager {
-  constructor(db, pair, config, logger, writeQueue, decisionMachineRunner$1, usageCounters2) {
-    super(db, pair, config, logger, writeQueue);
-    this.config = config;
-    this.decisionMachineRunner = decisionMachineRunner$1 ?? new decisionMachineRunner.DecisionMachineRunner(db);
-    this.usageCounters = usageCounters2 ?? null;
-  }
-  /**
-   * Provide the routing-machine context for this request. When set, the
-   * frictionless flow's send*Captcha calls will (a) invoke the routing
-   * machine to potentially override the baseline captcha type, and (b) emit
-   * fire-and-forget served-counter writes after the session is created.
-   *
-   * Not called on maintenance-mode or configured-captchaType short-circuit
-   * paths — those skip routing entirely.
-   */
-  setRoutingContext(ctx) {
-    this.routingContext = ctx;
-  }
-  /**
-   * Evaluate the configured routing machine against an arbitrary baseline +
-   * context, without going through `sendCaptcha`. Used by the dedup
-   * short-circuit to ask "if we reused this cached session, would the
-   * current routing machine still pick the same captchaType?" — if not,
-   * the cached session is evicted and the request falls through into the
-   * normal decision-machine flow (which will run the router again with
-   * fully-derived inputs).
-   *
-   * Returns the supplied baseline on any failure (no machine, machine
-   * throws, counter fetch failure, etc.), matching applyRouter's contract.
-   */
-  async applyRoutingMachine(baseline, ctx) {
-    return routingMachine.applyRouter(
-      this.decisionMachineRunner,
-      this.usageCounters,
-      baseline,
-      ctx,
-      this.logger
-    );
-  }
-  setSessionParams(params) {
-    this.sessionParams = {
-      token: params.token,
-      score: params.score,
-      threshold: params.threshold,
-      scoreComponents: params.scoreComponents,
-      ipAddress: params.ipAddress,
-      webView: params.webView ?? false,
-      iFrame: params.iFrame ?? false,
-      decryptedHeadHash: params.decryptedHeadHash,
-      siteKey: params.siteKey,
-      currentUrl: params.currentUrl,
-      iframeUrl: params.iframeUrl,
-      isProtect: params.isProtect,
-      ipInfo: params.ipInfo,
-      headers: params.headers,
-      mode: params.mode,
-      simdReadings: params.simdReadings,
-      entropyMathRandomFingerprint: params.entropyMathRandomFingerprint,
-      entropyCryptoFingerprint: params.entropyCryptoFingerprint,
-      entropyWallClockOffsetMs: params.entropyWallClockOffsetMs,
-      entropyMathRandomFirst: params.entropyMathRandomFirst,
-      tcpToChelloUs: params.tcpToChelloUs,
-      chelloToHandshakeUs: params.chelloToHandshakeUs
-    };
-  }
-  updateScore(score, scoreComponents) {
-    if (this.sessionParams) {
-      this.sessionParams.score = score;
-      this.sessionParams.scoreComponents = scoreComponents;
-    }
-  }
-  checkLangRules(acceptLanguage) {
-    return lang.checkLangRules(this.config, acceptLanguage);
-  }
-  async createSession(token, score, threshold, scoreComponents, ipAddress, captchaType, siteKey, solvedImagesCount, powDifficulty, userSitekeyIpHash, webView = false, iFrame = false, decryptedHeadHash = "", reason, blocked, deleted, ipInfo, headers, mode, simdReadings, entropyMathRandomFingerprint, entropyCryptoFingerprint, entropyWallClockOffsetMs, entropyMathRandomFirst, currentUrl, tcpToChelloUs, chelloToHandshakeUs, isEscalation, iframeUrl, isProtect) {
-    const sessionRecord = {
-      sessionId: `${getSessionIDPrefix(this.config.host)}-${uuid.v4()}`,
-      createdAt: /* @__PURE__ */ new Date(),
-      token,
-      score,
-      threshold,
-      scoreComponents,
-      ipAddress,
-      captchaType,
-      mode,
-      solvedImagesCount,
-      powDifficulty,
-      userSitekeyIpHash,
-      webView,
-      iFrame,
-      // Only persist the escalation flag when it's actually true —
-      // avoids polluting analytics with `false` on every plain
-      // frictionless session.
-      ...isEscalation && { isEscalation: true },
-      decryptedHeadHash,
-      reason,
-      siteKey,
-      currentUrl,
-      iframeUrl,
-      // Same rationale as isEscalation above: only persist the flag
-      // when it's actually true so non-Protect sessions stay slim and
-      // the sparse index on {isProtect, createdAt} carries only the
-      // Protect subset.
-      ...isProtect && { isProtect: true },
-      blocked,
-      deleted,
-      ipInfo,
-      headers,
-      simdReadings,
-      // Tag the arrival stage when the readings actually came in on
-      // this hop. Absence of readings → absence of stage.
-      ...simdReadings && {
-        simdReadingsStage: types.SimdReadingsStage.frictionless
-      },
-      entropyMathRandomFingerprint,
-      entropyCryptoFingerprint,
-      entropyWallClockOffsetMs,
-      entropyMathRandomFirst,
-      tcpToChelloUs,
-      chelloToHandshakeUs
-    };
-    await this.db.storeSessionRecord(sessionRecord);
-    if (this.writeQueue) {
-      const cacheData = sessionRecord;
-      const cachePromises = [
-        this.writeQueue.cacheSession(sessionRecord.sessionId, cacheData)
-      ];
-      if (userSitekeyIpHash) {
-        cachePromises.push(
-          this.writeQueue.cacheSessionByHash(
-            userSitekeyIpHash,
-            sessionRecord.sessionId
-          )
-        );
-      }
-      await Promise.all(cachePromises).catch(() => {
-      });
-    }
-    return sessionRecord;
-  }
-  async sendImageCaptcha(params) {
-    return this.sendCaptcha(types.CaptchaType.image, params);
-  }
-  async sendPowCaptcha(params) {
-    return this.sendCaptcha(types.CaptchaType.pow, params);
-  }
-  async sendPuzzleCaptcha(params) {
-    return this.sendCaptcha(types.CaptchaType.puzzle, params);
-  }
-  // Shared body for the three concrete `send*Captcha` helpers. Each helper is
-  // kept as its own thin wrapper so call-sites read clearly, but session
-  // validation and the createSession invocation only live in one place.
-  async sendCaptcha(captchaType, params) {
-    const effectiveParams = { ...this.sessionParams, ...params };
-    if (!effectiveParams.token || effectiveParams.score === void 0 || effectiveParams.threshold === void 0 || !effectiveParams.scoreComponents || !effectiveParams.ipAddress || effectiveParams.siteKey === void 0) {
-      throw new Error(
-        `Session parameters must be set before sending a ${captchaType} captcha`
-      );
-    }
-    const baseline = {
-      captchaType,
-      solvedImagesCount: captchaType === types.CaptchaType.image ? effectiveParams.solvedImagesCount : void 0,
-      powDifficulty: captchaType === types.CaptchaType.pow ? effectiveParams.powDifficulty : void 0
-    };
-    const routed = this.routingContext ? await routingMachine.applyRouter(
-      this.decisionMachineRunner,
-      this.usageCounters,
-      baseline,
-      this.routingContext,
-      this.logger
-    ) : baseline;
-    const finalCaptchaType = routed.captchaType;
-    const finalSolvedImagesCount = finalCaptchaType === types.CaptchaType.image ? routed.solvedImagesCount ?? effectiveParams.solvedImagesCount : void 0;
-    const finalPowDifficulty = finalCaptchaType === types.CaptchaType.pow ? routed.powDifficulty ?? effectiveParams.powDifficulty : void 0;
-    const blocked = finalCaptchaType === types.CaptchaType.image ? effectiveParams.blocked : void 0;
-    const sessionRecord = await this.createSession(
-      effectiveParams.token,
-      effectiveParams.score,
-      effectiveParams.threshold,
-      effectiveParams.scoreComponents,
-      effectiveParams.ipAddress,
-      finalCaptchaType,
-      effectiveParams.siteKey,
-      finalSolvedImagesCount,
-      finalPowDifficulty,
-      effectiveParams.userSitekeyIpHash,
-      effectiveParams.webView ?? false,
-      effectiveParams.iFrame ?? false,
-      effectiveParams.decryptedHeadHash,
-      effectiveParams.reason,
-      blocked,
-      void 0,
-      effectiveParams.ipInfo,
-      effectiveParams.headers,
-      effectiveParams.mode,
-      effectiveParams.simdReadings,
-      effectiveParams.entropyMathRandomFingerprint,
-      effectiveParams.entropyCryptoFingerprint,
-      effectiveParams.entropyWallClockOffsetMs,
-      effectiveParams.entropyMathRandomFirst,
-      effectiveParams.currentUrl,
-      effectiveParams.tcpToChelloUs,
-      effectiveParams.chelloToHandshakeUs,
-      void 0,
-      effectiveParams.iframeUrl,
-      effectiveParams.isProtect
-    );
-    if (this.routingContext && this.usageCounters) {
-      this.usageCounters.incrManyAsync(
-        this.routingContext.dappAccount,
-        usageCounters.buildAllWindowIncrements(
-          "served",
-          finalCaptchaType,
-          this.routingContext.ip,
-          this.routingContext.userAccount
-        )
-      );
-    }
-    return {
-      [types.ApiParams.captchaType]: finalCaptchaType,
-      [types.ApiParams.sessionId]: sessionRecord.sessionId,
-      [types.ApiParams.status]: "ok",
-      dns_url: dnsEventUrl.buildDnsEventUrl(sessionRecord.sessionId)
-    };
-  }
-  async registerBlockedSession(params) {
-    const effectiveParams = { ...this.sessionParams, ...params };
-    if (!effectiveParams.token || effectiveParams.score === void 0 || effectiveParams.threshold === void 0 || !effectiveParams.scoreComponents || !effectiveParams.ipAddress || effectiveParams.siteKey === void 0) {
-      throw new Error(
-        "Session parameters must be set before calling registerBlockedSession"
-      );
-    }
-    await this.createSession(
-      effectiveParams.token,
-      effectiveParams.score,
-      effectiveParams.threshold,
-      effectiveParams.scoreComponents,
-      effectiveParams.ipAddress,
-      types.CaptchaType.image,
-      effectiveParams.siteKey,
-      effectiveParams.solvedImagesCount,
-      void 0,
-      effectiveParams.userSitekeyIpHash,
-      effectiveParams.webView ?? false,
-      effectiveParams.iFrame ?? false,
-      effectiveParams.decryptedHeadHash,
-      effectiveParams.reason,
-      true,
-      true,
-      effectiveParams.ipInfo,
-      effectiveParams.headers,
-      effectiveParams.mode,
-      effectiveParams.simdReadings,
-      effectiveParams.entropyMathRandomFingerprint,
-      effectiveParams.entropyCryptoFingerprint,
-      effectiveParams.entropyWallClockOffsetMs,
-      effectiveParams.entropyMathRandomFirst,
-      effectiveParams.currentUrl,
-      effectiveParams.tcpToChelloUs,
-      effectiveParams.chelloToHandshakeUs,
-      void 0,
-      effectiveParams.iframeUrl,
-      effectiveParams.isProtect
-    );
-  }
-  scoreIncreaseAccessPolicy(accessPolicy, baseBotScore, botScore, scoreComponents) {
-    const accessPolicyPenalty = accessPolicy?.frictionlessScore || this.config.penalties.PENALTY_ACCESS_RULE;
-    botScore += accessPolicyPenalty;
-    return {
-      score: botScore,
-      scoreComponents: {
-        ...scoreComponents,
-        accessPolicy: accessPolicyPenalty
-      }
-    };
-  }
-  scoreIncreaseWebView(baseBotScore, botScore, scoreComponents) {
-    this.logger.debug(() => ({
-      msg: "WebView detected"
-    }));
-    botScore += this.config.penalties.PENALTY_WEBVIEW;
-    return {
-      score: botScore,
-      scoreComponents: {
-        ...scoreComponents,
-        webView: this.config.penalties.PENALTY_WEBVIEW
-      }
-    };
-  }
-  scoreIncreaseTimestamp(timestamp, baseBotScore, botScore, scoreComponents) {
-    this.logger.info(() => ({
-      msg: "Timestamp is older than 10 minutes",
-      data: { timestamp: new Date(timestamp) }
-    }));
-    botScore += this.config.penalties.PENALTY_OLD_TIMESTAMP;
-    return {
-      score: botScore,
-      scoreComponents: {
-        ...scoreComponents,
-        timeout: this.config.penalties.PENALTY_OLD_TIMESTAMP
-      }
-    };
-  }
-  static timestampTooOld(timestamp) {
-    const now = Date.now();
-    const diff = now - timestamp;
-    return diff > DEFAULT_MAX_TIMESTAMP_AGE;
-  }
-  /**
-   * Redacts a key for logging purposes by showing only the first 5, middle 10, and last 5 characters
-   * @param key - The key to redact
-   * @returns Redacted key string or empty string if key is falsy
-   */
-  redactKeyForLogging(key) {
-    if (!key) return "";
-    const start = key.slice(0, 5);
-    const middle = key.slice(
-      Math.floor(key.length / 2) - 5,
-      Math.floor(key.length / 2) + 5
-    );
-    const end = key.slice(-5);
-    return `${start}...${middle}...${end}`;
-  }
-  async decryptPayload(token, headHash) {
-    const decryptKeys = [
-      // Process DB keys first, then env var key last as env key will likely be invalid
-      ...await this.getDetectorKeys(),
-      process.env.BOT_DECRYPTION_KEY
-    ].filter((k) => k);
-    this.logger.debug(() => {
-      const loggedKeys = decryptKeys.map(
-        (key) => this.redactKeyForLogging(key)
-      );
-      return {
-        msg: "Decrypting score",
-        data: {
-          keysLength: decryptKeys.length,
-          keys: loggedKeys
-        }
-      };
-    });
-    let baseBotScore;
-    let timestamp;
-    let userId;
-    let userAgent;
-    let webView;
-    let iFrame;
-    let decryptedHeadHash = "";
-    let decryptionFailed = false;
-    let triggeredDetectors;
-    let shadowDomPenalty;
-    let entropyMathRandomFingerprint;
-    let entropyCryptoFingerprint;
-    let entropyWallClockOffsetMs;
-    let entropyMathRandomFirst;
-    for (const [keyIndex, key] of decryptKeys.entries()) {
-      try {
-        this.logger.info(() => ({
-          msg: "Attempting to decrypt score",
-          data: {
-            key: this.redactKeyForLogging(key)
-          }
-        }));
-        const decrypted = await getBotScore.getBotScore(token, headHash, key);
-        decryptedHeadHash = decrypted.decryptedHeadHash || "";
-        const s = decrypted.baseBotScore;
-        const t = decrypted.timestamp;
-        const a = decrypted.userId;
-        const u = decrypted.userAgent;
-        const w = decrypted.isWebView;
-        const i = decrypted.isIframe;
-        const td = decrypted.triggeredDetectors;
-        const sd = decrypted.shadowDomPenalty;
-        const ef = decrypted.entropyMathRandomFingerprint;
-        const ec = decrypted.entropyCryptoFingerprint;
-        const eo = decrypted.entropyWallClockOffsetMs;
-        const em = decrypted.entropyMathRandomFirst;
-        this.logger.debug(() => ({
-          msg: "Successfully decrypted score",
-          data: {
-            key: this.redactKeyForLogging(key),
-            baseBotScore: s,
-            timestamp: t,
-            userId: a,
-            userAgent: u,
-            webView: w,
-            iFrame: i,
-            triggeredDetectors: td,
-            shadowDomPenalty: sd,
-            entropyMathRandomFingerprint: ef,
-            entropyCryptoFingerprint: ec,
-            entropyWallClockOffsetMs: eo,
-            entropyMathRandomFirst: em
-          }
-        }));
-        baseBotScore = s;
-        timestamp = t;
-        userId = a;
-        userAgent = u;
-        webView = w;
-        iFrame = i;
-        triggeredDetectors = td;
-        shadowDomPenalty = sd;
-        entropyMathRandomFingerprint = ef;
-        entropyCryptoFingerprint = ec;
-        entropyWallClockOffsetMs = eo;
-        entropyMathRandomFirst = em;
-        break;
-      } catch (err) {
-        if (keyIndex === decryptKeys.length - 1) {
-          this.logger.warn(() => ({
-            msg: "Error decrypting score: no more keys to try"
-          }));
-          baseBotScore = 1;
-          timestamp = 0;
-          decryptedHeadHash = "";
-          decryptionFailed = true;
-        }
-      }
-    }
-    const baseBotScoreUndefined = baseBotScore === void 0 || Number.isNaN(baseBotScore);
-    const timestampUndefined = timestamp === void 0 || Number.isNaN(timestamp);
-    const undefinedCount = Number(baseBotScoreUndefined) + Number(timestampUndefined);
-    if (undefinedCount > 0) {
-      this.logger.error(() => ({
-        msg: "Error decrypting score: baseBotScore or timestamp is undefined"
-      }));
-      baseBotScore = 1;
-      timestamp = 0;
-      decryptedHeadHash = "";
-      decryptionFailed = true;
-    }
-    this.logger.info(() => ({
-      msg: "decryptPayload result",
-      data: {
-        baseBotScore,
-        timestamp,
-        userId,
-        userAgent,
-        webView,
-        iFrame,
-        decryptedHeadHash,
-        decryptionFailed,
-        shadowDomPenalty
-      }
-    }));
-    return {
-      baseBotScore: Number(baseBotScore),
-      timestamp: Number(timestamp),
-      userId,
-      userAgent,
-      webView: webView || false,
-      iFrame: iFrame || false,
-      decryptedHeadHash,
-      decryptionFailed,
-      triggeredDetectors,
-      shadowDomPenalty,
-      entropyMathRandomFingerprint,
-      entropyCryptoFingerprint,
-      entropyWallClockOffsetMs,
-      entropyMathRandomFirst
-    };
-  }
-  async getClientContextEntropy(siteKey, contextType) {
-    return this.db.getClientContextEntropy(siteKey, contextType);
-  }
-}
-Object.defineProperty(exports, "FrictionlessReason", {
-  enumerable: true,
-  get: () => types.FrictionlessReason
-});
+var FrictionlessManager = class extends require_captchaManager.CaptchaManager {
+	constructor(db, pair, config, logger, writeQueue, decisionMachineRunner, usageCounters) {
+		super(db, pair, config, logger, writeQueue);
+		this.config = config;
+		this.decisionMachineRunner = decisionMachineRunner ?? new require_decisionMachineRunner.DecisionMachineRunner(db);
+		this.usageCounters = usageCounters ?? null;
+	}
+	/**
+	* Provide the routing-machine context for this request. When set, the
+	* frictionless flow's send*Captcha calls will (a) invoke the routing
+	* machine to potentially override the baseline captcha type, and (b) emit
+	* fire-and-forget served-counter writes after the session is created.
+	*
+	* Not called on maintenance-mode or configured-captchaType short-circuit
+	* paths — those skip routing entirely.
+	*/
+	setRoutingContext(ctx) {
+		this.routingContext = ctx;
+	}
+	/**
+	* Evaluate the configured routing machine against an arbitrary baseline +
+	* context, without going through `sendCaptcha`. Used by the dedup
+	* short-circuit to ask "if we reused this cached session, would the
+	* current routing machine still pick the same captchaType?" — if not,
+	* the cached session is evicted and the request falls through into the
+	* normal decision-machine flow (which will run the router again with
+	* fully-derived inputs).
+	*
+	* Returns the supplied baseline on any failure (no machine, machine
+	* throws, counter fetch failure, etc.), matching applyRouter's contract.
+	*/
+	async applyRoutingMachine(baseline, ctx) {
+		return require_routingMachine.applyRouter(this.decisionMachineRunner, this.usageCounters, baseline, ctx, this.logger);
+	}
+	setSessionParams(params) {
+		this.sessionParams = {
+			token: params.token,
+			score: params.score,
+			threshold: params.threshold,
+			scoreComponents: params.scoreComponents,
+			ipAddress: params.ipAddress,
+			webView: params.webView ?? false,
+			iFrame: params.iFrame ?? false,
+			decryptedHeadHash: params.decryptedHeadHash,
+			siteKey: params.siteKey,
+			currentUrl: params.currentUrl,
+			iframeUrl: params.iframeUrl,
+			isProtect: params.isProtect,
+			ipInfo: params.ipInfo,
+			headers: params.headers,
+			mode: params.mode,
+			simdReadings: params.simdReadings,
+			entropyMathRandomFingerprint: params.entropyMathRandomFingerprint,
+			entropyCryptoFingerprint: params.entropyCryptoFingerprint,
+			entropyWallClockOffsetMs: params.entropyWallClockOffsetMs,
+			entropyMathRandomFirst: params.entropyMathRandomFirst,
+			tcpToChelloUs: params.tcpToChelloUs,
+			chelloToHandshakeUs: params.chelloToHandshakeUs
+		};
+	}
+	updateScore(score, scoreComponents) {
+		if (this.sessionParams) {
+			this.sessionParams.score = score;
+			this.sessionParams.scoreComponents = scoreComponents;
+		}
+	}
+	checkLangRules(acceptLanguage) {
+		return require_lang.checkLangRules(this.config, acceptLanguage);
+	}
+	async createSession(token, score, threshold, scoreComponents, ipAddress, captchaType, siteKey, solvedImagesCount, powDifficulty, userSitekeyIpHash, webView = false, iFrame = false, decryptedHeadHash = "", reason, blocked, deleted, ipInfo, headers, mode, simdReadings, entropyMathRandomFingerprint, entropyCryptoFingerprint, entropyWallClockOffsetMs, entropyMathRandomFirst, currentUrl, tcpToChelloUs, chelloToHandshakeUs, isEscalation, iframeUrl, isProtect) {
+		const sessionRecord = {
+			sessionId: `${getSessionIDPrefix(this.config.host)}-${(0, uuid.v4)()}`,
+			createdAt: /* @__PURE__ */ new Date(),
+			token,
+			score,
+			threshold,
+			scoreComponents,
+			ipAddress,
+			captchaType,
+			mode,
+			solvedImagesCount,
+			powDifficulty,
+			userSitekeyIpHash,
+			webView,
+			iFrame,
+			...isEscalation && { isEscalation: true },
+			decryptedHeadHash,
+			reason,
+			siteKey,
+			currentUrl,
+			iframeUrl,
+			...isProtect && { isProtect: true },
+			blocked,
+			deleted,
+			ipInfo,
+			headers,
+			simdReadings,
+			...simdReadings && { simdReadingsStage: _prosopo_types.SimdReadingsStage.frictionless },
+			entropyMathRandomFingerprint,
+			entropyCryptoFingerprint,
+			entropyWallClockOffsetMs,
+			entropyMathRandomFirst,
+			tcpToChelloUs,
+			chelloToHandshakeUs
+		};
+		await this.db.storeSessionRecord(sessionRecord);
+		if (this.writeQueue) {
+			const cacheData = sessionRecord;
+			const cachePromises = [this.writeQueue.cacheSession(sessionRecord.sessionId, cacheData)];
+			if (userSitekeyIpHash) cachePromises.push(this.writeQueue.cacheSessionByHash(userSitekeyIpHash, sessionRecord.sessionId));
+			await Promise.all(cachePromises).catch(() => {});
+		}
+		return sessionRecord;
+	}
+	async sendImageCaptcha(params) {
+		return this.sendCaptcha(_prosopo_types.CaptchaType.image, params);
+	}
+	async sendPowCaptcha(params) {
+		return this.sendCaptcha(_prosopo_types.CaptchaType.pow, params);
+	}
+	async sendPuzzleCaptcha(params) {
+		return this.sendCaptcha(_prosopo_types.CaptchaType.puzzle, params);
+	}
+	async sendCaptcha(captchaType, params) {
+		const effectiveParams = {
+			...this.sessionParams,
+			...params
+		};
+		if (!effectiveParams.token || effectiveParams.score === void 0 || effectiveParams.threshold === void 0 || !effectiveParams.scoreComponents || !effectiveParams.ipAddress || effectiveParams.siteKey === void 0) throw new Error(`Session parameters must be set before sending a ${captchaType} captcha`);
+		const baseline = {
+			captchaType,
+			solvedImagesCount: captchaType === _prosopo_types.CaptchaType.image ? effectiveParams.solvedImagesCount : void 0,
+			powDifficulty: captchaType === _prosopo_types.CaptchaType.pow ? effectiveParams.powDifficulty : void 0
+		};
+		const routed = this.routingContext ? await require_routingMachine.applyRouter(this.decisionMachineRunner, this.usageCounters, baseline, this.routingContext, this.logger) : baseline;
+		const finalCaptchaType = routed.captchaType;
+		const finalSolvedImagesCount = finalCaptchaType === _prosopo_types.CaptchaType.image ? routed.solvedImagesCount ?? effectiveParams.solvedImagesCount : void 0;
+		const finalPowDifficulty = finalCaptchaType === _prosopo_types.CaptchaType.pow ? routed.powDifficulty ?? effectiveParams.powDifficulty : void 0;
+		const blocked = finalCaptchaType === _prosopo_types.CaptchaType.image ? effectiveParams.blocked : void 0;
+		const sessionRecord = await this.createSession(effectiveParams.token, effectiveParams.score, effectiveParams.threshold, effectiveParams.scoreComponents, effectiveParams.ipAddress, finalCaptchaType, effectiveParams.siteKey, finalSolvedImagesCount, finalPowDifficulty, effectiveParams.userSitekeyIpHash, effectiveParams.webView ?? false, effectiveParams.iFrame ?? false, effectiveParams.decryptedHeadHash, effectiveParams.reason, blocked, void 0, effectiveParams.ipInfo, effectiveParams.headers, effectiveParams.mode, effectiveParams.simdReadings, effectiveParams.entropyMathRandomFingerprint, effectiveParams.entropyCryptoFingerprint, effectiveParams.entropyWallClockOffsetMs, effectiveParams.entropyMathRandomFirst, effectiveParams.currentUrl, effectiveParams.tcpToChelloUs, effectiveParams.chelloToHandshakeUs, void 0, effectiveParams.iframeUrl, effectiveParams.isProtect);
+		if (this.routingContext && this.usageCounters) this.usageCounters.incrManyAsync(this.routingContext.dappAccount, require_usageCounters.buildAllWindowIncrements("served", finalCaptchaType, this.routingContext.ip, this.routingContext.userAccount));
+		return {
+			[_prosopo_types.ApiParams.captchaType]: finalCaptchaType,
+			[_prosopo_types.ApiParams.sessionId]: sessionRecord.sessionId,
+			[_prosopo_types.ApiParams.status]: "ok",
+			dns_url: require_dnsEventUrl.buildDnsEventUrl(sessionRecord.sessionId)
+		};
+	}
+	async registerBlockedSession(params) {
+		const effectiveParams = {
+			...this.sessionParams,
+			...params
+		};
+		if (!effectiveParams.token || effectiveParams.score === void 0 || effectiveParams.threshold === void 0 || !effectiveParams.scoreComponents || !effectiveParams.ipAddress || effectiveParams.siteKey === void 0) throw new Error("Session parameters must be set before calling registerBlockedSession");
+		await this.createSession(effectiveParams.token, effectiveParams.score, effectiveParams.threshold, effectiveParams.scoreComponents, effectiveParams.ipAddress, _prosopo_types.CaptchaType.image, effectiveParams.siteKey, effectiveParams.solvedImagesCount, void 0, effectiveParams.userSitekeyIpHash, effectiveParams.webView ?? false, effectiveParams.iFrame ?? false, effectiveParams.decryptedHeadHash, effectiveParams.reason, true, true, effectiveParams.ipInfo, effectiveParams.headers, effectiveParams.mode, effectiveParams.simdReadings, effectiveParams.entropyMathRandomFingerprint, effectiveParams.entropyCryptoFingerprint, effectiveParams.entropyWallClockOffsetMs, effectiveParams.entropyMathRandomFirst, effectiveParams.currentUrl, effectiveParams.tcpToChelloUs, effectiveParams.chelloToHandshakeUs, void 0, effectiveParams.iframeUrl, effectiveParams.isProtect);
+	}
+	scoreIncreaseAccessPolicy(accessPolicy, baseBotScore, botScore, scoreComponents) {
+		const accessPolicyPenalty = accessPolicy?.frictionlessScore || this.config.penalties.PENALTY_ACCESS_RULE;
+		botScore += accessPolicyPenalty;
+		return {
+			score: botScore,
+			scoreComponents: {
+				...scoreComponents,
+				accessPolicy: accessPolicyPenalty
+			}
+		};
+	}
+	scoreIncreaseWebView(baseBotScore, botScore, scoreComponents) {
+		this.logger.debug(() => ({ msg: "WebView detected" }));
+		botScore += this.config.penalties.PENALTY_WEBVIEW;
+		return {
+			score: botScore,
+			scoreComponents: {
+				...scoreComponents,
+				webView: this.config.penalties.PENALTY_WEBVIEW
+			}
+		};
+	}
+	scoreIncreaseTimestamp(timestamp, baseBotScore, botScore, scoreComponents) {
+		this.logger.info(() => ({
+			msg: "Timestamp is older than 10 minutes",
+			data: { timestamp: new Date(timestamp) }
+		}));
+		botScore += this.config.penalties.PENALTY_OLD_TIMESTAMP;
+		return {
+			score: botScore,
+			scoreComponents: {
+				...scoreComponents,
+				timeout: this.config.penalties.PENALTY_OLD_TIMESTAMP
+			}
+		};
+	}
+	static timestampTooOld(timestamp) {
+		return Date.now() - timestamp > DEFAULT_MAX_TIMESTAMP_AGE;
+	}
+	/**
+	* Redacts a key for logging purposes by showing only the first 5, middle 10, and last 5 characters
+	* @param key - The key to redact
+	* @returns Redacted key string or empty string if key is falsy
+	*/
+	redactKeyForLogging(key) {
+		if (!key) return "";
+		return `${key.slice(0, 5)}...${key.slice(Math.floor(key.length / 2) - 5, Math.floor(key.length / 2) + 5)}...${key.slice(-5)}`;
+	}
+	async decryptPayload(token, headHash) {
+		const decryptKeys = [...await this.getDetectorKeys(), process.env.BOT_DECRYPTION_KEY].filter((k) => k);
+		this.logger.debug(() => {
+			const loggedKeys = decryptKeys.map((key) => this.redactKeyForLogging(key));
+			return {
+				msg: "Decrypting score",
+				data: {
+					keysLength: decryptKeys.length,
+					keys: loggedKeys
+				}
+			};
+		});
+		let baseBotScore;
+		let timestamp;
+		let userId;
+		let userAgent;
+		let webView;
+		let iFrame;
+		let decryptedHeadHash = "";
+		let decryptionFailed = false;
+		let triggeredDetectors;
+		let shadowDomPenalty;
+		let entropyMathRandomFingerprint;
+		let entropyCryptoFingerprint;
+		let entropyWallClockOffsetMs;
+		let entropyMathRandomFirst;
+		for (const [keyIndex, key] of decryptKeys.entries()) try {
+			this.logger.info(() => ({
+				msg: "Attempting to decrypt score",
+				data: { key: this.redactKeyForLogging(key) }
+			}));
+			const decrypted = await require_getBotScore.getBotScore(token, headHash, key);
+			decryptedHeadHash = decrypted.decryptedHeadHash || "";
+			const s = decrypted.baseBotScore;
+			const t = decrypted.timestamp;
+			const a = decrypted.userId;
+			const u = decrypted.userAgent;
+			const w = decrypted.isWebView;
+			const i = decrypted.isIframe;
+			const td = decrypted.triggeredDetectors;
+			const sd = decrypted.shadowDomPenalty;
+			const ef = decrypted.entropyMathRandomFingerprint;
+			const ec = decrypted.entropyCryptoFingerprint;
+			const eo = decrypted.entropyWallClockOffsetMs;
+			const em = decrypted.entropyMathRandomFirst;
+			this.logger.debug(() => ({
+				msg: "Successfully decrypted score",
+				data: {
+					key: this.redactKeyForLogging(key),
+					baseBotScore: s,
+					timestamp: t,
+					userId: a,
+					userAgent: u,
+					webView: w,
+					iFrame: i,
+					triggeredDetectors: td,
+					shadowDomPenalty: sd,
+					entropyMathRandomFingerprint: ef,
+					entropyCryptoFingerprint: ec,
+					entropyWallClockOffsetMs: eo,
+					entropyMathRandomFirst: em
+				}
+			}));
+			baseBotScore = s;
+			timestamp = t;
+			userId = a;
+			userAgent = u;
+			webView = w;
+			iFrame = i;
+			triggeredDetectors = td;
+			shadowDomPenalty = sd;
+			entropyMathRandomFingerprint = ef;
+			entropyCryptoFingerprint = ec;
+			entropyWallClockOffsetMs = eo;
+			entropyMathRandomFirst = em;
+			break;
+		} catch (err) {
+			if (keyIndex === decryptKeys.length - 1) {
+				this.logger.warn(() => ({ msg: "Error decrypting score: no more keys to try" }));
+				baseBotScore = 1;
+				timestamp = 0;
+				decryptedHeadHash = "";
+				decryptionFailed = true;
+			}
+		}
+		const baseBotScoreUndefined = baseBotScore === void 0 || Number.isNaN(baseBotScore);
+		const timestampUndefined = timestamp === void 0 || Number.isNaN(timestamp);
+		if (Number(baseBotScoreUndefined) + Number(timestampUndefined) > 0) {
+			this.logger.error(() => ({ msg: "Error decrypting score: baseBotScore or timestamp is undefined" }));
+			baseBotScore = 1;
+			timestamp = 0;
+			decryptedHeadHash = "";
+			decryptionFailed = true;
+		}
+		this.logger.info(() => ({
+			msg: "decryptPayload result",
+			data: {
+				baseBotScore,
+				timestamp,
+				userId,
+				userAgent,
+				webView,
+				iFrame,
+				decryptedHeadHash,
+				decryptionFailed,
+				shadowDomPenalty
+			}
+		}));
+		return {
+			baseBotScore: Number(baseBotScore),
+			timestamp: Number(timestamp),
+			userId,
+			userAgent,
+			webView: webView || false,
+			iFrame: iFrame || false,
+			decryptedHeadHash,
+			decryptionFailed,
+			triggeredDetectors,
+			shadowDomPenalty,
+			entropyMathRandomFingerprint,
+			entropyCryptoFingerprint,
+			entropyWallClockOffsetMs,
+			entropyMathRandomFirst
+		};
+	}
+	async getClientContextEntropy(siteKey, contextType) {
+		return this.db.getClientContextEntropy(siteKey, contextType);
+	}
+};
+//#endregion
 exports.FrictionlessManager = FrictionlessManager;
+exports.FrictionlessReason = _prosopo_types.FrictionlessReason;