@rpcbase/server 0.489.0 → 0.490.0

package/dist/index.js

@@ -1,4628 +0,0 @@
-import session from "express-session";
-import { RedisStore } from "connect-redis";
-import MongoStore from "connect-mongo";
-import { createClient } from "redis";
-import { MongoClient } from "mongodb";
-import env from "@rpcbase/env";
-import { initApiClient, SsrErrorFallback, SSR_ERROR_STATE_GLOBAL_KEY, serializeSsrErrorState } from "@rpcbase/client";
-import { dirname, posix, sep } from "path";
-import fs, { createReadStream, readFileSync } from "node:fs";
-import { createInterface } from "node:readline";
-import { AsyncLocalStorage } from "node:async_hooks";
-import assert$1 from "assert";
-import crypto, { hkdfSync, scrypt } from "crypto";
-import httpProxy from "http-proxy-3";
-import fsPromises from "node:fs/promises";
-import inspector from "node:inspector";
-import path from "node:path";
-import { fileURLToPath } from "node:url";
-import { Transform } from "node:stream";
-import { StrictMode, createElement } from "react";
-import { renderToPipeableStream, renderToStaticMarkup } from "react-dom/server";
-import { jsx } from "react/jsx-runtime";
-import { createPath, matchRoutes, parsePath, createStaticRouter, StaticRouterProvider } from "@rpcbase/router";
-import { s } from "./email-DEw8keax.js";
-function getDefaultExportFromCjs(x) {
-  return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, "default") ? x["default"] : x;
-}
-var is_1;
-var hasRequiredIs;
-function requireIs() {
-  if (hasRequiredIs) return is_1;
-  hasRequiredIs = 1;
-  var regexes = {
-    ipv4: /^(?:(?:\d|[1-9]\d|1\d{2}|2[0-4]\d|25[0-5])\.){3}(?:\d|[1-9]\d|1\d{2}|2[0-4]\d|25[0-5])$/,
-    ipv6: /^((?=.*::)(?!.*::.+::)(::)?([\dA-F]{1,4}:(:|\b)|){5}|([\dA-F]{1,4}:){6})((([\dA-F]{1,4}((?!\3)::|:\b|$))|(?!\2\3)){2}|(((2[0-4]|1\d|[1-9])?\d|25[0-5])\.?\b){4})$/i
-  };
-  function not(func) {
-    return function() {
-      return !func.apply(null, Array.prototype.slice.call(arguments));
-    };
-  }
-  function existy(value) {
-    return value != null;
-  }
-  function ip(value) {
-    return existy(value) && regexes.ipv4.test(value) || regexes.ipv6.test(value);
-  }
-  function object(value) {
-    return Object(value) === value;
-  }
-  function string(value) {
-    return Object.prototype.toString.call(value) === "[object String]";
-  }
-  var is = {
-    existy,
-    ip,
-    object,
-    string,
-    not: {
-      existy: not(existy),
-      ip: not(ip),
-      object: not(object),
-      string: not(string)
-    }
-  };
-  is_1 = is;
-  return is_1;
-}
-var lib;
-var hasRequiredLib;
-function requireLib() {
-  if (hasRequiredLib) return lib;
-  hasRequiredLib = 1;
-  function _typeof(obj) {
-    "@babel/helpers - typeof";
-    return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(obj2) {
-      return typeof obj2;
-    } : function(obj2) {
-      return obj2 && "function" == typeof Symbol && obj2.constructor === Symbol && obj2 !== Symbol.prototype ? "symbol" : typeof obj2;
-    }, _typeof(obj);
-  }
-  var is = requireIs();
-  function getClientIpFromXForwardedFor(value) {
-    if (!is.existy(value)) {
-      return null;
-    }
-    if (is.not.string(value)) {
-      throw new TypeError('Expected a string, got "'.concat(_typeof(value), '"'));
-    }
-    var forwardedIps = value.split(",").map(function(e) {
-      var ip = e.trim();
-      if (ip.includes(":")) {
-        var splitted = ip.split(":");
-        if (splitted.length === 2) {
-          return splitted[0];
-        }
-      }
-      return ip;
-    });
-    for (var i = 0; i < forwardedIps.length; i++) {
-      if (is.ip(forwardedIps[i])) {
-        return forwardedIps[i];
-      }
-    }
-    return null;
-  }
-  function getClientIp(req) {
-    if (req.headers) {
-      if (is.ip(req.headers["x-client-ip"])) {
-        return req.headers["x-client-ip"];
-      }
-      var xForwardedFor = getClientIpFromXForwardedFor(req.headers["x-forwarded-for"]);
-      if (is.ip(xForwardedFor)) {
-        return xForwardedFor;
-      }
-      if (is.ip(req.headers["cf-connecting-ip"])) {
-        return req.headers["cf-connecting-ip"];
-      }
-      if (is.ip(req.headers["fastly-client-ip"])) {
-        return req.headers["fastly-client-ip"];
-      }
-      if (is.ip(req.headers["true-client-ip"])) {
-        return req.headers["true-client-ip"];
-      }
-      if (is.ip(req.headers["x-real-ip"])) {
-        return req.headers["x-real-ip"];
-      }
-      if (is.ip(req.headers["x-cluster-client-ip"])) {
-        return req.headers["x-cluster-client-ip"];
-      }
-      if (is.ip(req.headers["x-forwarded"])) {
-        return req.headers["x-forwarded"];
-      }
-      if (is.ip(req.headers["forwarded-for"])) {
-        return req.headers["forwarded-for"];
-      }
-      if (is.ip(req.headers.forwarded)) {
-        return req.headers.forwarded;
-      }
-      if (is.ip(req.headers["x-appengine-user-ip"])) {
-        return req.headers["x-appengine-user-ip"];
-      }
-    }
-    if (is.existy(req.connection)) {
-      if (is.ip(req.connection.remoteAddress)) {
-        return req.connection.remoteAddress;
-      }
-      if (is.existy(req.connection.socket) && is.ip(req.connection.socket.remoteAddress)) {
-        return req.connection.socket.remoteAddress;
-      }
-    }
-    if (is.existy(req.socket) && is.ip(req.socket.remoteAddress)) {
-      return req.socket.remoteAddress;
-    }
-    if (is.existy(req.info) && is.ip(req.info.remoteAddress)) {
-      return req.info.remoteAddress;
-    }
-    if (is.existy(req.requestContext) && is.existy(req.requestContext.identity) && is.ip(req.requestContext.identity.sourceIp)) {
-      return req.requestContext.identity.sourceIp;
-    }
-    if (req.headers) {
-      if (is.ip(req.headers["Cf-Pseudo-IPv4"])) {
-        return req.headers["Cf-Pseudo-IPv4"];
-      }
-    }
-    if (is.existy(req.raw)) {
-      return getClientIp(req.raw);
-    }
-    return null;
-  }
-  function mw(options) {
-    var configuration = is.not.existy(options) ? {} : options;
-    if (is.not.object(configuration)) {
-      throw new TypeError("Options must be an object!");
-    }
-    var attributeName = configuration.attributeName || "clientIp";
-    return function(req, res, next) {
-      var ip = getClientIp(req);
-      Object.defineProperty(req, attributeName, {
-        get: function get() {
-          return ip;
-        },
-        configurable: true
-      });
-      next();
-    };
-  }
-  lib = {
-    getClientIpFromXForwardedFor,
-    getClientIp,
-    mw
-  };
-  return lib;
-}
-var libExports = requireLib();
-const requestIp = /* @__PURE__ */ getDefaultExportFromCjs(libExports);
-function createModulerModifier() {
-  const getModuleFromFileName = createGetModuleFromFilename();
-  return async (frames) => {
-    for (const frame of frames) frame.module = getModuleFromFileName(frame.filename);
-    return frames;
-  };
-}
-function createGetModuleFromFilename(basePath = process.argv[1] ? dirname(process.argv[1]) : process.cwd(), isWindows = "\\" === sep) {
-  const normalizedBase = isWindows ? normalizeWindowsPath(basePath) : basePath;
-  return (filename) => {
-    if (!filename) return;
-    const normalizedFilename = isWindows ? normalizeWindowsPath(filename) : filename;
-    let { dir, base: file, ext } = posix.parse(normalizedFilename);
-    if (".js" === ext || ".mjs" === ext || ".cjs" === ext) file = file.slice(0, -1 * ext.length);
-    const decodedFile = decodeURIComponent(file);
-    if (!dir) dir = ".";
-    const n = dir.lastIndexOf("/node_modules");
-    if (n > -1) return `${dir.slice(n + 14).replace(/\//g, ".")}:${decodedFile}`;
-    if (dir.startsWith(normalizedBase)) {
-      const moduleName = dir.slice(normalizedBase.length + 1).replace(/\//g, ".");
-      return moduleName ? `${moduleName}:${decodedFile}` : decodedFile;
-    }
-    return decodedFile;
-  };
-}
-function normalizeWindowsPath(path2) {
-  return path2.replace(/^[A-Z]:/, "").replace(/\\/g, "/");
-}
-const normalizeFlagsResponse = (flagsResponse) => {
-  if ("flags" in flagsResponse) {
-    const featureFlags = getFlagValuesFromFlags(flagsResponse.flags);
-    const featureFlagPayloads = getPayloadsFromFlags(flagsResponse.flags);
-    return {
-      ...flagsResponse,
-      featureFlags,
-      featureFlagPayloads
-    };
-  }
-  {
-    const featureFlags = flagsResponse.featureFlags ?? {};
-    const featureFlagPayloads = Object.fromEntries(Object.entries(flagsResponse.featureFlagPayloads || {}).map(([k, v]) => [
-      k,
-      parsePayload(v)
-    ]));
-    const flags = Object.fromEntries(Object.entries(featureFlags).map(([key, value]) => [
-      key,
-      getFlagDetailFromFlagAndPayload(key, value, featureFlagPayloads[key])
-    ]));
-    return {
-      ...flagsResponse,
-      featureFlags,
-      featureFlagPayloads,
-      flags
-    };
-  }
-};
-function getFlagDetailFromFlagAndPayload(key, value, payload) {
-  return {
-    key,
-    enabled: "string" == typeof value ? true : value,
-    variant: "string" == typeof value ? value : void 0,
-    reason: void 0,
-    metadata: {
-      id: void 0,
-      version: void 0,
-      payload: payload ? JSON.stringify(payload) : void 0,
-      description: void 0
-    }
-  };
-}
-const getFlagValuesFromFlags = (flags) => Object.fromEntries(Object.entries(flags ?? {}).map(([key, detail]) => [
-  key,
-  getFeatureFlagValue(detail)
-]).filter(([, value]) => void 0 !== value));
-const getPayloadsFromFlags = (flags) => {
-  const safeFlags = flags ?? {};
-  return Object.fromEntries(Object.keys(safeFlags).filter((flag) => {
-    const details = safeFlags[flag];
-    return details.enabled && details.metadata && void 0 !== details.metadata.payload;
-  }).map((flag) => {
-    const payload = safeFlags[flag].metadata?.payload;
-    return [
-      flag,
-      payload ? parsePayload(payload) : void 0
-    ];
-  }));
-};
-const getFeatureFlagValue = (detail) => void 0 === detail ? void 0 : detail.variant ?? detail.enabled;
-const parsePayload = (response) => {
-  if ("string" != typeof response) return response;
-  try {
-    return JSON.parse(response);
-  } catch {
-    return response;
-  }
-};
-const DIGITS = "0123456789abcdef";
-class UUID {
-  constructor(bytes) {
-    this.bytes = bytes;
-  }
-  static ofInner(bytes) {
-    if (16 === bytes.length) return new UUID(bytes);
-    throw new TypeError("not 128-bit length");
-  }
-  static fromFieldsV7(unixTsMs, randA, randBHi, randBLo) {
-    if (!Number.isInteger(unixTsMs) || !Number.isInteger(randA) || !Number.isInteger(randBHi) || !Number.isInteger(randBLo) || unixTsMs < 0 || randA < 0 || randBHi < 0 || randBLo < 0 || unixTsMs > 281474976710655 || randA > 4095 || randBHi > 1073741823 || randBLo > 4294967295) throw new RangeError("invalid field value");
-    const bytes = new Uint8Array(16);
-    bytes[0] = unixTsMs / 2 ** 40;
-    bytes[1] = unixTsMs / 2 ** 32;
-    bytes[2] = unixTsMs / 2 ** 24;
-    bytes[3] = unixTsMs / 2 ** 16;
-    bytes[4] = unixTsMs / 256;
-    bytes[5] = unixTsMs;
-    bytes[6] = 112 | randA >>> 8;
-    bytes[7] = randA;
-    bytes[8] = 128 | randBHi >>> 24;
-    bytes[9] = randBHi >>> 16;
-    bytes[10] = randBHi >>> 8;
-    bytes[11] = randBHi;
-    bytes[12] = randBLo >>> 24;
-    bytes[13] = randBLo >>> 16;
-    bytes[14] = randBLo >>> 8;
-    bytes[15] = randBLo;
-    return new UUID(bytes);
-  }
-  static parse(uuid) {
-    let hex;
-    switch (uuid.length) {
-      case 32:
-        hex = /^[0-9a-f]{32}$/i.exec(uuid)?.[0];
-        break;
-      case 36:
-        hex = /^([0-9a-f]{8})-([0-9a-f]{4})-([0-9a-f]{4})-([0-9a-f]{4})-([0-9a-f]{12})$/i.exec(uuid)?.slice(1, 6).join("");
-        break;
-      case 38:
-        hex = /^\{([0-9a-f]{8})-([0-9a-f]{4})-([0-9a-f]{4})-([0-9a-f]{4})-([0-9a-f]{12})\}$/i.exec(uuid)?.slice(1, 6).join("");
-        break;
-      case 45:
-        hex = /^urn:uuid:([0-9a-f]{8})-([0-9a-f]{4})-([0-9a-f]{4})-([0-9a-f]{4})-([0-9a-f]{12})$/i.exec(uuid)?.slice(1, 6).join("");
-        break;
-    }
-    if (hex) {
-      const inner = new Uint8Array(16);
-      for (let i = 0; i < 16; i += 4) {
-        const n = parseInt(hex.substring(2 * i, 2 * i + 8), 16);
-        inner[i + 0] = n >>> 24;
-        inner[i + 1] = n >>> 16;
-        inner[i + 2] = n >>> 8;
-        inner[i + 3] = n;
-      }
-      return new UUID(inner);
-    }
-    throw new SyntaxError("could not parse UUID string");
-  }
-  toString() {
-    let text = "";
-    for (let i = 0; i < this.bytes.length; i++) {
-      text += DIGITS.charAt(this.bytes[i] >>> 4);
-      text += DIGITS.charAt(15 & this.bytes[i]);
-      if (3 === i || 5 === i || 7 === i || 9 === i) text += "-";
-    }
-    return text;
-  }
-  toHex() {
-    let text = "";
-    for (let i = 0; i < this.bytes.length; i++) {
-      text += DIGITS.charAt(this.bytes[i] >>> 4);
-      text += DIGITS.charAt(15 & this.bytes[i]);
-    }
-    return text;
-  }
-  toJSON() {
-    return this.toString();
-  }
-  getVariant() {
-    const n = this.bytes[8] >>> 4;
-    if (n < 0) throw new Error("unreachable");
-    if (n <= 7) return this.bytes.every((e) => 0 === e) ? "NIL" : "VAR_0";
-    if (n <= 11) return "VAR_10";
-    if (n <= 13) return "VAR_110";
-    if (n <= 15) return this.bytes.every((e) => 255 === e) ? "MAX" : "VAR_RESERVED";
-    else throw new Error("unreachable");
-  }
-  getVersion() {
-    return "VAR_10" === this.getVariant() ? this.bytes[6] >>> 4 : void 0;
-  }
-  clone() {
-    return new UUID(this.bytes.slice(0));
-  }
-  equals(other) {
-    return 0 === this.compareTo(other);
-  }
-  compareTo(other) {
-    for (let i = 0; i < 16; i++) {
-      const diff = this.bytes[i] - other.bytes[i];
-      if (0 !== diff) return Math.sign(diff);
-    }
-    return 0;
-  }
-}
-class V7Generator {
-  constructor(randomNumberGenerator) {
-    this.timestamp = 0;
-    this.counter = 0;
-    this.random = randomNumberGenerator ?? getDefaultRandom();
-  }
-  generate() {
-    return this.generateOrResetCore(Date.now(), 1e4);
-  }
-  generateOrAbort() {
-    return this.generateOrAbortCore(Date.now(), 1e4);
-  }
-  generateOrResetCore(unixTsMs, rollbackAllowance) {
-    let value = this.generateOrAbortCore(unixTsMs, rollbackAllowance);
-    if (void 0 === value) {
-      this.timestamp = 0;
-      value = this.generateOrAbortCore(unixTsMs, rollbackAllowance);
-    }
-    return value;
-  }
-  generateOrAbortCore(unixTsMs, rollbackAllowance) {
-    const MAX_COUNTER = 4398046511103;
-    if (!Number.isInteger(unixTsMs) || unixTsMs < 1 || unixTsMs > 281474976710655) throw new RangeError("`unixTsMs` must be a 48-bit positive integer");
-    if (rollbackAllowance < 0 || rollbackAllowance > 281474976710655) throw new RangeError("`rollbackAllowance` out of reasonable range");
-    if (unixTsMs > this.timestamp) {
-      this.timestamp = unixTsMs;
-      this.resetCounter();
-    } else {
-      if (!(unixTsMs + rollbackAllowance >= this.timestamp)) return;
-      this.counter++;
-      if (this.counter > MAX_COUNTER) {
-        this.timestamp++;
-        this.resetCounter();
-      }
-    }
-    return UUID.fromFieldsV7(this.timestamp, Math.trunc(this.counter / 2 ** 30), this.counter & 2 ** 30 - 1, this.random.nextUint32());
-  }
-  resetCounter() {
-    this.counter = 1024 * this.random.nextUint32() + (1023 & this.random.nextUint32());
-  }
-  generateV4() {
-    const bytes = new Uint8Array(Uint32Array.of(this.random.nextUint32(), this.random.nextUint32(), this.random.nextUint32(), this.random.nextUint32()).buffer);
-    bytes[6] = 64 | bytes[6] >>> 4;
-    bytes[8] = 128 | bytes[8] >>> 2;
-    return UUID.ofInner(bytes);
-  }
-}
-const getDefaultRandom = () => ({
-  nextUint32: () => 65536 * Math.trunc(65536 * Math.random()) + Math.trunc(65536 * Math.random())
-});
-let defaultGenerator;
-const uuidv7 = () => uuidv7obj().toString();
-const uuidv7obj = () => (defaultGenerator || (defaultGenerator = new V7Generator())).generate();
-const DEFAULT_BLOCKED_UA_STRS = [
-  "amazonbot",
-  "amazonproductbot",
-  "app.hypefactors.com",
-  "applebot",
-  "archive.org_bot",
-  "awariobot",
-  "backlinksextendedbot",
-  "baiduspider",
-  "bingbot",
-  "bingpreview",
-  "chrome-lighthouse",
-  "dataforseobot",
-  "deepscan",
-  "duckduckbot",
-  "facebookexternal",
-  "facebookcatalog",
-  "http://yandex.com/bots",
-  "hubspot",
-  "ia_archiver",
-  "leikibot",
-  "linkedinbot",
-  "meta-externalagent",
-  "mj12bot",
-  "msnbot",
-  "nessus",
-  "petalbot",
-  "pinterest",
-  "prerender",
-  "rogerbot",
-  "screaming frog",
-  "sebot-wa",
-  "sitebulb",
-  "slackbot",
-  "slurp",
-  "trendictionbot",
-  "turnitin",
-  "twitterbot",
-  "vercel-screenshot",
-  "vercelbot",
-  "yahoo! slurp",
-  "yandexbot",
-  "zoombot",
-  "bot.htm",
-  "bot.php",
-  "(bot;",
-  "bot/",
-  "crawler",
-  "ahrefsbot",
-  "ahrefssiteaudit",
-  "semrushbot",
-  "siteauditbot",
-  "splitsignalbot",
-  "gptbot",
-  "oai-searchbot",
-  "chatgpt-user",
-  "perplexitybot",
-  "better uptime bot",
-  "sentryuptimebot",
-  "uptimerobot",
-  "headlesschrome",
-  "cypress",
-  "google-hoteladsverifier",
-  "adsbot-google",
-  "apis-google",
-  "duplexweb-google",
-  "feedfetcher-google",
-  "google favicon",
-  "google web preview",
-  "google-read-aloud",
-  "googlebot",
-  "googleother",
-  "google-cloudvertexbot",
-  "googleweblight",
-  "mediapartners-google",
-  "storebot-google",
-  "google-inspectiontool",
-  "bytespider"
-];
-const isBlockedUA = function(ua, customBlockedUserAgents = []) {
-  if (!ua) return false;
-  const uaLower = ua.toLowerCase();
-  return DEFAULT_BLOCKED_UA_STRS.concat(customBlockedUserAgents).some((blockedUA) => {
-    const blockedUaLower = blockedUA.toLowerCase();
-    return -1 !== uaLower.indexOf(blockedUaLower);
-  });
-};
-var types_PostHogPersistedProperty = /* @__PURE__ */ (function(PostHogPersistedProperty) {
-  PostHogPersistedProperty["AnonymousId"] = "anonymous_id";
-  PostHogPersistedProperty["DistinctId"] = "distinct_id";
-  PostHogPersistedProperty["Props"] = "props";
-  PostHogPersistedProperty["FeatureFlagDetails"] = "feature_flag_details";
-  PostHogPersistedProperty["FeatureFlags"] = "feature_flags";
-  PostHogPersistedProperty["FeatureFlagPayloads"] = "feature_flag_payloads";
-  PostHogPersistedProperty["BootstrapFeatureFlagDetails"] = "bootstrap_feature_flag_details";
-  PostHogPersistedProperty["BootstrapFeatureFlags"] = "bootstrap_feature_flags";
-  PostHogPersistedProperty["BootstrapFeatureFlagPayloads"] = "bootstrap_feature_flag_payloads";
-  PostHogPersistedProperty["OverrideFeatureFlags"] = "override_feature_flags";
-  PostHogPersistedProperty["Queue"] = "queue";
-  PostHogPersistedProperty["OptedOut"] = "opted_out";
-  PostHogPersistedProperty["SessionId"] = "session_id";
-  PostHogPersistedProperty["SessionStartTimestamp"] = "session_start_timestamp";
-  PostHogPersistedProperty["SessionLastTimestamp"] = "session_timestamp";
-  PostHogPersistedProperty["PersonProperties"] = "person_properties";
-  PostHogPersistedProperty["GroupProperties"] = "group_properties";
-  PostHogPersistedProperty["InstalledAppBuild"] = "installed_app_build";
-  PostHogPersistedProperty["InstalledAppVersion"] = "installed_app_version";
-  PostHogPersistedProperty["SessionReplay"] = "session_replay";
-  PostHogPersistedProperty["SurveyLastSeenDate"] = "survey_last_seen_date";
-  PostHogPersistedProperty["SurveysSeen"] = "surveys_seen";
-  PostHogPersistedProperty["Surveys"] = "surveys";
-  PostHogPersistedProperty["RemoteConfig"] = "remote_config";
-  PostHogPersistedProperty["FlagsEndpointWasHit"] = "flags_endpoint_was_hit";
-  return PostHogPersistedProperty;
-})({});
-const nativeIsArray = Array.isArray;
-const ObjProto = Object.prototype;
-const type_utils_toString = ObjProto.toString;
-const isArray = nativeIsArray || function(obj) {
-  return "[object Array]" === type_utils_toString.call(obj);
-};
-const isObject = (x) => x === Object(x) && !isArray(x);
-const isUndefined = (x) => void 0 === x;
-const isString = (x) => "[object String]" == type_utils_toString.call(x);
-const isEmptyString = (x) => isString(x) && 0 === x.trim().length;
-const isNumber = (x) => "[object Number]" == type_utils_toString.call(x);
-const isPlainError = (x) => x instanceof Error;
-function isPrimitive(value) {
-  return null === value || "object" != typeof value;
-}
-function isBuiltin(candidate, className) {
-  return Object.prototype.toString.call(candidate) === `[object ${className}]`;
-}
-function isEvent(candidate) {
-  return !isUndefined(Event) && isInstanceOf(candidate, Event);
-}
-function isPlainObject(candidate) {
-  return isBuiltin(candidate, "Object");
-}
-function isInstanceOf(candidate, base) {
-  try {
-    return candidate instanceof base;
-  } catch {
-    return false;
-  }
-}
-function clampToRange(value, min, max, logger, fallbackValue) {
-  if (min > max) {
-    logger.warn("min cannot be greater than max.");
-    min = max;
-  }
-  if (isNumber(value)) if (value > max) {
-    logger.warn(" cannot be  greater than max: " + max + ". Using max value instead.");
-    return max;
-  } else {
-    if (!(value < min)) return value;
-    logger.warn(" cannot be less than min: " + min + ". Using min value instead.");
-    return min;
-  }
-  logger.warn(" must be a number. using max or fallback. max: " + max + ", fallback: " + fallbackValue);
-  return clampToRange(max, min, max, logger);
-}
-const ONE_DAY_IN_MS = 864e5;
-class BucketedRateLimiter {
-  constructor(options) {
-    this._buckets = {};
-    this._onBucketRateLimited = options._onBucketRateLimited;
-    this._bucketSize = clampToRange(options.bucketSize, 0, 100, options._logger);
-    this._refillRate = clampToRange(options.refillRate, 0, this._bucketSize, options._logger);
-    this._refillInterval = clampToRange(options.refillInterval, 0, ONE_DAY_IN_MS, options._logger);
-  }
-  _applyRefill(bucket, now) {
-    const elapsedMs = now - bucket.lastAccess;
-    const refillIntervals = Math.floor(elapsedMs / this._refillInterval);
-    if (refillIntervals > 0) {
-      const tokensToAdd = refillIntervals * this._refillRate;
-      bucket.tokens = Math.min(bucket.tokens + tokensToAdd, this._bucketSize);
-      bucket.lastAccess = bucket.lastAccess + refillIntervals * this._refillInterval;
-    }
-  }
-  consumeRateLimit(key) {
-    const now = Date.now();
-    const keyStr = String(key);
-    let bucket = this._buckets[keyStr];
-    if (bucket) this._applyRefill(bucket, now);
-    else {
-      bucket = {
-        tokens: this._bucketSize,
-        lastAccess: now
-      };
-      this._buckets[keyStr] = bucket;
-    }
-    if (0 === bucket.tokens) return true;
-    bucket.tokens--;
-    if (0 === bucket.tokens) this._onBucketRateLimited?.(key);
-    return 0 === bucket.tokens;
-  }
-  stop() {
-    this._buckets = {};
-  }
-}
-class PromiseQueue {
-  add(promise) {
-    const promiseUUID = uuidv7();
-    this.promiseByIds[promiseUUID] = promise;
-    promise.catch(() => {
-    }).finally(() => {
-      delete this.promiseByIds[promiseUUID];
-    });
-    return promise;
-  }
-  async join() {
-    let promises = Object.values(this.promiseByIds);
-    let length = promises.length;
-    while (length > 0) {
-      await Promise.all(promises);
-      promises = Object.values(this.promiseByIds);
-      length = promises.length;
-    }
-  }
-  get length() {
-    return Object.keys(this.promiseByIds).length;
-  }
-  constructor() {
-    this.promiseByIds = {};
-  }
-}
-function createConsole(consoleLike = console) {
-  const lockedMethods = {
-    log: consoleLike.log.bind(consoleLike),
-    warn: consoleLike.warn.bind(consoleLike),
-    error: consoleLike.error.bind(consoleLike),
-    debug: consoleLike.debug.bind(consoleLike)
-  };
-  return lockedMethods;
-}
-const _createLogger = (prefix, maybeCall, consoleLike) => {
-  function _log(level, ...args) {
-    maybeCall(() => {
-      const consoleMethod = consoleLike[level];
-      consoleMethod(prefix, ...args);
-    });
-  }
-  const logger = {
-    info: (...args) => {
-      _log("log", ...args);
-    },
-    warn: (...args) => {
-      _log("warn", ...args);
-    },
-    error: (...args) => {
-      _log("error", ...args);
-    },
-    critical: (...args) => {
-      consoleLike["error"](prefix, ...args);
-    },
-    createLogger: (additionalPrefix) => _createLogger(`${prefix} ${additionalPrefix}`, maybeCall, consoleLike)
-  };
-  return logger;
-};
-const passThrough = (fn) => fn();
-function createLogger(prefix, maybeCall = passThrough) {
-  return _createLogger(prefix, maybeCall, createConsole());
-}
-const STRING_FORMAT = "utf8";
-function assert(truthyValue, message) {
-  if (!truthyValue || "string" != typeof truthyValue || isEmpty(truthyValue)) throw new Error(message);
-}
-function isEmpty(truthyValue) {
-  if (0 === truthyValue.trim().length) return true;
-  return false;
-}
-function removeTrailingSlash(url) {
-  return url?.replace(/\/+$/, "");
-}
-async function retriable(fn, props) {
-  let lastError = null;
-  for (let i = 0; i < props.retryCount + 1; i++) {
-    if (i > 0) await new Promise((r) => setTimeout(r, props.retryDelay));
-    try {
-      const res = await fn();
-      return res;
-    } catch (e) {
-      lastError = e;
-      if (!props.retryCheck(e)) throw e;
-    }
-  }
-  throw lastError;
-}
-function currentISOTime() {
-  return (/* @__PURE__ */ new Date()).toISOString();
-}
-function safeSetTimeout(fn, timeout) {
-  const t = setTimeout(fn, timeout);
-  t?.unref && t?.unref();
-  return t;
-}
-const isError = (x) => x instanceof Error;
-function allSettled(promises) {
-  return Promise.all(promises.map((p) => (p ?? Promise.resolve()).then((value) => ({
-    status: "fulfilled",
-    value
-  }), (reason) => ({
-    status: "rejected",
-    reason
-  }))));
-}
-class SimpleEventEmitter {
-  constructor() {
-    this.events = {};
-    this.events = {};
-  }
-  on(event, listener) {
-    if (!this.events[event]) this.events[event] = [];
-    this.events[event].push(listener);
-    return () => {
-      this.events[event] = this.events[event].filter((x) => x !== listener);
-    };
-  }
-  emit(event, payload) {
-    for (const listener of this.events[event] || []) listener(payload);
-    for (const listener of this.events["*"] || []) listener(event, payload);
-  }
-}
-function isGzipSupported() {
-  return "CompressionStream" in globalThis;
-}
-async function gzipCompress(input, isDebug = true) {
-  try {
-    const dataStream = new Blob([
-      input
-    ], {
-      type: "text/plain"
-    }).stream();
-    const compressedStream = dataStream.pipeThrough(new CompressionStream("gzip"));
-    return await new Response(compressedStream).blob();
-  } catch (error) {
-    if (isDebug) console.error("Failed to gzip compress data", error);
-    return null;
-  }
-}
-class PostHogFetchHttpError extends Error {
-  constructor(response, reqByteLength) {
-    super("HTTP error while fetching PostHog: status=" + response.status + ", reqByteLength=" + reqByteLength), this.response = response, this.reqByteLength = reqByteLength, this.name = "PostHogFetchHttpError";
-  }
-  get status() {
-    return this.response.status;
-  }
-  get text() {
-    return this.response.text();
-  }
-  get json() {
-    return this.response.json();
-  }
-}
-class PostHogFetchNetworkError extends Error {
-  constructor(error) {
-    super("Network error while fetching PostHog", error instanceof Error ? {
-      cause: error
-    } : {}), this.error = error, this.name = "PostHogFetchNetworkError";
-  }
-}
-async function logFlushError(err) {
-  if (err instanceof PostHogFetchHttpError) {
-    let text = "";
-    try {
-      text = await err.text;
-    } catch {
-    }
-    console.error(`Error while flushing PostHog: message=${err.message}, response body=${text}`, err);
-  } else console.error("Error while flushing PostHog", err);
-  return Promise.resolve();
-}
-function isPostHogFetchError(err) {
-  return "object" == typeof err && (err instanceof PostHogFetchHttpError || err instanceof PostHogFetchNetworkError);
-}
-function isPostHogFetchContentTooLargeError(err) {
-  return "object" == typeof err && err instanceof PostHogFetchHttpError && 413 === err.status;
-}
-class PostHogCoreStateless {
-  constructor(apiKey, options = {}) {
-    this.flushPromise = null;
-    this.shutdownPromise = null;
-    this.promiseQueue = new PromiseQueue();
-    this._events = new SimpleEventEmitter();
-    this._isInitialized = false;
-    assert(apiKey, "You must pass your PostHog project's api key.");
-    this.apiKey = apiKey;
-    this.host = removeTrailingSlash(options.host || "https://us.i.posthog.com");
-    this.flushAt = options.flushAt ? Math.max(options.flushAt, 1) : 20;
-    this.maxBatchSize = Math.max(this.flushAt, options.maxBatchSize ?? 100);
-    this.maxQueueSize = Math.max(this.flushAt, options.maxQueueSize ?? 1e3);
-    this.flushInterval = options.flushInterval ?? 1e4;
-    this.preloadFeatureFlags = options.preloadFeatureFlags ?? true;
-    this.defaultOptIn = options.defaultOptIn ?? true;
-    this.disableSurveys = options.disableSurveys ?? false;
-    this._retryOptions = {
-      retryCount: options.fetchRetryCount ?? 3,
-      retryDelay: options.fetchRetryDelay ?? 3e3,
-      retryCheck: isPostHogFetchError
-    };
-    this.requestTimeout = options.requestTimeout ?? 1e4;
-    this.featureFlagsRequestTimeoutMs = options.featureFlagsRequestTimeoutMs ?? 3e3;
-    this.remoteConfigRequestTimeoutMs = options.remoteConfigRequestTimeoutMs ?? 3e3;
-    this.disableGeoip = options.disableGeoip ?? true;
-    this.disabled = options.disabled ?? false;
-    this.historicalMigration = options?.historicalMigration ?? false;
-    this.evaluationEnvironments = options?.evaluationEnvironments;
-    this._initPromise = Promise.resolve();
-    this._isInitialized = true;
-    this._logger = createLogger("[PostHog]", this.logMsgIfDebug.bind(this));
-    this.disableCompression = !isGzipSupported() || (options?.disableCompression ?? false);
-  }
-  logMsgIfDebug(fn) {
-    if (this.isDebug) fn();
-  }
-  wrap(fn) {
-    if (this.disabled) return void this._logger.warn("The client is disabled");
-    if (this._isInitialized) return fn();
-    this._initPromise.then(() => fn());
-  }
-  getCommonEventProperties() {
-    return {
-      $lib: this.getLibraryId(),
-      $lib_version: this.getLibraryVersion()
-    };
-  }
-  get optedOut() {
-    return this.getPersistedProperty(types_PostHogPersistedProperty.OptedOut) ?? !this.defaultOptIn;
-  }
-  async optIn() {
-    this.wrap(() => {
-      this.setPersistedProperty(types_PostHogPersistedProperty.OptedOut, false);
-    });
-  }
-  async optOut() {
-    this.wrap(() => {
-      this.setPersistedProperty(types_PostHogPersistedProperty.OptedOut, true);
-    });
-  }
-  on(event, cb) {
-    return this._events.on(event, cb);
-  }
-  debug(enabled = true) {
-    this.removeDebugCallback?.();
-    if (enabled) {
-      const removeDebugCallback = this.on("*", (event, payload) => this._logger.info(event, payload));
-      this.removeDebugCallback = () => {
-        removeDebugCallback();
-        this.removeDebugCallback = void 0;
-      };
-    }
-  }
-  get isDebug() {
-    return !!this.removeDebugCallback;
-  }
-  get isDisabled() {
-    return this.disabled;
-  }
-  buildPayload(payload) {
-    return {
-      distinct_id: payload.distinct_id,
-      event: payload.event,
-      properties: {
-        ...payload.properties || {},
-        ...this.getCommonEventProperties()
-      }
-    };
-  }
-  addPendingPromise(promise) {
-    return this.promiseQueue.add(promise);
-  }
-  identifyStateless(distinctId, properties, options) {
-    this.wrap(() => {
-      const payload = {
-        ...this.buildPayload({
-          distinct_id: distinctId,
-          event: "$identify",
-          properties
-        })
-      };
-      this.enqueue("identify", payload, options);
-    });
-  }
-  async identifyStatelessImmediate(distinctId, properties, options) {
-    const payload = {
-      ...this.buildPayload({
-        distinct_id: distinctId,
-        event: "$identify",
-        properties
-      })
-    };
-    await this.sendImmediate("identify", payload, options);
-  }
-  captureStateless(distinctId, event, properties, options) {
-    this.wrap(() => {
-      const payload = this.buildPayload({
-        distinct_id: distinctId,
-        event,
-        properties
-      });
-      this.enqueue("capture", payload, options);
-    });
-  }
-  async captureStatelessImmediate(distinctId, event, properties, options) {
-    const payload = this.buildPayload({
-      distinct_id: distinctId,
-      event,
-      properties
-    });
-    await this.sendImmediate("capture", payload, options);
-  }
-  aliasStateless(alias, distinctId, properties, options) {
-    this.wrap(() => {
-      const payload = this.buildPayload({
-        event: "$create_alias",
-        distinct_id: distinctId,
-        properties: {
-          ...properties || {},
-          distinct_id: distinctId,
-          alias
-        }
-      });
-      this.enqueue("alias", payload, options);
-    });
-  }
-  async aliasStatelessImmediate(alias, distinctId, properties, options) {
-    const payload = this.buildPayload({
-      event: "$create_alias",
-      distinct_id: distinctId,
-      properties: {
-        ...properties || {},
-        distinct_id: distinctId,
-        alias
-      }
-    });
-    await this.sendImmediate("alias", payload, options);
-  }
-  groupIdentifyStateless(groupType, groupKey, groupProperties, options, distinctId, eventProperties) {
-    this.wrap(() => {
-      const payload = this.buildPayload({
-        distinct_id: distinctId || `$${groupType}_${groupKey}`,
-        event: "$groupidentify",
-        properties: {
-          $group_type: groupType,
-          $group_key: groupKey,
-          $group_set: groupProperties || {},
-          ...eventProperties || {}
-        }
-      });
-      this.enqueue("capture", payload, options);
-    });
-  }
-  async getRemoteConfig() {
-    await this._initPromise;
-    let host = this.host;
-    if ("https://us.i.posthog.com" === host) host = "https://us-assets.i.posthog.com";
-    else if ("https://eu.i.posthog.com" === host) host = "https://eu-assets.i.posthog.com";
-    const url = `${host}/array/${this.apiKey}/config`;
-    const fetchOptions = {
-      method: "GET",
-      headers: {
-        ...this.getCustomHeaders(),
-        "Content-Type": "application/json"
-      }
-    };
-    return this.fetchWithRetry(url, fetchOptions, {
-      retryCount: 0
-    }, this.remoteConfigRequestTimeoutMs).then((response) => response.json()).catch((error) => {
-      this._logger.error("Remote config could not be loaded", error);
-      this._events.emit("error", error);
-    });
-  }
-  async getFlags(distinctId, groups = {}, personProperties = {}, groupProperties = {}, extraPayload = {}, fetchConfig = true) {
-    await this._initPromise;
-    const configParam = fetchConfig ? "&config=true" : "";
-    const url = `${this.host}/flags/?v=2${configParam}`;
-    const requestData = {
-      token: this.apiKey,
-      distinct_id: distinctId,
-      groups,
-      person_properties: personProperties,
-      group_properties: groupProperties,
-      ...extraPayload
-    };
-    if (this.evaluationEnvironments && this.evaluationEnvironments.length > 0) requestData.evaluation_environments = this.evaluationEnvironments;
-    const fetchOptions = {
-      method: "POST",
-      headers: {
-        ...this.getCustomHeaders(),
-        "Content-Type": "application/json"
-      },
-      body: JSON.stringify(requestData)
-    };
-    this._logger.info("Flags URL", url);
-    return this.fetchWithRetry(url, fetchOptions, {
-      retryCount: 0
-    }, this.featureFlagsRequestTimeoutMs).then((response) => response.json()).then((response) => normalizeFlagsResponse(response)).catch((error) => {
-      this._events.emit("error", error);
-    });
-  }
-  async getFeatureFlagStateless(key, distinctId, groups = {}, personProperties = {}, groupProperties = {}, disableGeoip) {
-    await this._initPromise;
-    const flagDetailResponse = await this.getFeatureFlagDetailStateless(key, distinctId, groups, personProperties, groupProperties, disableGeoip);
-    if (void 0 === flagDetailResponse) return {
-      response: void 0,
-      requestId: void 0
-    };
-    let response = getFeatureFlagValue(flagDetailResponse.response);
-    if (void 0 === response) response = false;
-    return {
-      response,
-      requestId: flagDetailResponse.requestId
-    };
-  }
-  async getFeatureFlagDetailStateless(key, distinctId, groups = {}, personProperties = {}, groupProperties = {}, disableGeoip) {
-    await this._initPromise;
-    const flagsResponse = await this.getFeatureFlagDetailsStateless(distinctId, groups, personProperties, groupProperties, disableGeoip, [
-      key
-    ]);
-    if (void 0 === flagsResponse) return;
-    const featureFlags = flagsResponse.flags;
-    const flagDetail = featureFlags[key];
-    return {
-      response: flagDetail,
-      requestId: flagsResponse.requestId,
-      evaluatedAt: flagsResponse.evaluatedAt
-    };
-  }
-  async getFeatureFlagPayloadStateless(key, distinctId, groups = {}, personProperties = {}, groupProperties = {}, disableGeoip) {
-    await this._initPromise;
-    const payloads = await this.getFeatureFlagPayloadsStateless(distinctId, groups, personProperties, groupProperties, disableGeoip, [
-      key
-    ]);
-    if (!payloads) return;
-    const response = payloads[key];
-    if (void 0 === response) return null;
-    return response;
-  }
-  async getFeatureFlagPayloadsStateless(distinctId, groups = {}, personProperties = {}, groupProperties = {}, disableGeoip, flagKeysToEvaluate) {
-    await this._initPromise;
-    const payloads = (await this.getFeatureFlagsAndPayloadsStateless(distinctId, groups, personProperties, groupProperties, disableGeoip, flagKeysToEvaluate)).payloads;
-    return payloads;
-  }
-  async getFeatureFlagsStateless(distinctId, groups = {}, personProperties = {}, groupProperties = {}, disableGeoip, flagKeysToEvaluate) {
-    await this._initPromise;
-    return await this.getFeatureFlagsAndPayloadsStateless(distinctId, groups, personProperties, groupProperties, disableGeoip, flagKeysToEvaluate);
-  }
-  async getFeatureFlagsAndPayloadsStateless(distinctId, groups = {}, personProperties = {}, groupProperties = {}, disableGeoip, flagKeysToEvaluate) {
-    await this._initPromise;
-    const featureFlagDetails = await this.getFeatureFlagDetailsStateless(distinctId, groups, personProperties, groupProperties, disableGeoip, flagKeysToEvaluate);
-    if (!featureFlagDetails) return {
-      flags: void 0,
-      payloads: void 0,
-      requestId: void 0
-    };
-    return {
-      flags: featureFlagDetails.featureFlags,
-      payloads: featureFlagDetails.featureFlagPayloads,
-      requestId: featureFlagDetails.requestId
-    };
-  }
-  async getFeatureFlagDetailsStateless(distinctId, groups = {}, personProperties = {}, groupProperties = {}, disableGeoip, flagKeysToEvaluate) {
-    await this._initPromise;
-    const extraPayload = {};
-    if (disableGeoip ?? this.disableGeoip) extraPayload["geoip_disable"] = true;
-    if (flagKeysToEvaluate) extraPayload["flag_keys_to_evaluate"] = flagKeysToEvaluate;
-    const flagsResponse = await this.getFlags(distinctId, groups, personProperties, groupProperties, extraPayload);
-    if (void 0 === flagsResponse) return;
-    if (flagsResponse.errorsWhileComputingFlags) console.error("[FEATURE FLAGS] Error while computing feature flags, some flags may be missing or incorrect. Learn more at https://posthog.com/docs/feature-flags/best-practices");
-    if (flagsResponse.quotaLimited?.includes("feature_flags")) {
-      console.warn("[FEATURE FLAGS] Feature flags quota limit exceeded - feature flags unavailable. Learn more about billing limits at https://posthog.com/docs/billing/limits-alerts");
-      return {
-        flags: {},
-        featureFlags: {},
-        featureFlagPayloads: {},
-        requestId: flagsResponse?.requestId,
-        quotaLimited: flagsResponse.quotaLimited
-      };
-    }
-    return flagsResponse;
-  }
-  async getSurveysStateless() {
-    await this._initPromise;
-    if (true === this.disableSurveys) {
-      this._logger.info("Loading surveys is disabled.");
-      return [];
-    }
-    const url = `${this.host}/api/surveys/?token=${this.apiKey}`;
-    const fetchOptions = {
-      method: "GET",
-      headers: {
-        ...this.getCustomHeaders(),
-        "Content-Type": "application/json"
-      }
-    };
-    const response = await this.fetchWithRetry(url, fetchOptions).then((response2) => {
-      if (200 !== response2.status || !response2.json) {
-        const msg = `Surveys API could not be loaded: ${response2.status}`;
-        const error = new Error(msg);
-        this._logger.error(error);
-        this._events.emit("error", new Error(msg));
-        return;
-      }
-      return response2.json();
-    }).catch((error) => {
-      this._logger.error("Surveys API could not be loaded", error);
-      this._events.emit("error", error);
-    });
-    const newSurveys = response?.surveys;
-    if (newSurveys) this._logger.info("Surveys fetched from API: ", JSON.stringify(newSurveys));
-    return newSurveys ?? [];
-  }
-  get props() {
-    if (!this._props) this._props = this.getPersistedProperty(types_PostHogPersistedProperty.Props);
-    return this._props || {};
-  }
-  set props(val) {
-    this._props = val;
-  }
-  async register(properties) {
-    this.wrap(() => {
-      this.props = {
-        ...this.props,
-        ...properties
-      };
-      this.setPersistedProperty(types_PostHogPersistedProperty.Props, this.props);
-    });
-  }
-  async unregister(property) {
-    this.wrap(() => {
-      delete this.props[property];
-      this.setPersistedProperty(types_PostHogPersistedProperty.Props, this.props);
-    });
-  }
-  enqueue(type, _message, options) {
-    this.wrap(() => {
-      if (this.optedOut) return void this._events.emit(type, "Library is disabled. Not sending event. To re-enable, call posthog.optIn()");
-      const message = this.prepareMessage(type, _message, options);
-      const queue = this.getPersistedProperty(types_PostHogPersistedProperty.Queue) || [];
-      if (queue.length >= this.maxQueueSize) {
-        queue.shift();
-        this._logger.info("Queue is full, the oldest event is dropped.");
-      }
-      queue.push({
-        message
-      });
-      this.setPersistedProperty(types_PostHogPersistedProperty.Queue, queue);
-      this._events.emit(type, message);
-      if (queue.length >= this.flushAt) this.flushBackground();
-      if (this.flushInterval && !this._flushTimer) this._flushTimer = safeSetTimeout(() => this.flushBackground(), this.flushInterval);
-    });
-  }
-  async sendImmediate(type, _message, options) {
-    if (this.disabled) return void this._logger.warn("The client is disabled");
-    if (!this._isInitialized) await this._initPromise;
-    if (this.optedOut) return void this._events.emit(type, "Library is disabled. Not sending event. To re-enable, call posthog.optIn()");
-    const data = {
-      api_key: this.apiKey,
-      batch: [
-        this.prepareMessage(type, _message, options)
-      ],
-      sent_at: currentISOTime()
-    };
-    if (this.historicalMigration) data.historical_migration = true;
-    const payload = JSON.stringify(data);
-    const url = `${this.host}/batch/`;
-    const gzippedPayload = this.disableCompression ? null : await gzipCompress(payload, this.isDebug);
-    const fetchOptions = {
-      method: "POST",
-      headers: {
-        ...this.getCustomHeaders(),
-        "Content-Type": "application/json",
-        ...null !== gzippedPayload && {
-          "Content-Encoding": "gzip"
-        }
-      },
-      body: gzippedPayload || payload
-    };
-    try {
-      await this.fetchWithRetry(url, fetchOptions);
-    } catch (err) {
-      this._events.emit("error", err);
-    }
-  }
-  prepareMessage(type, _message, options) {
-    const message = {
-      ..._message,
-      type,
-      library: this.getLibraryId(),
-      library_version: this.getLibraryVersion(),
-      timestamp: options?.timestamp ? options?.timestamp : currentISOTime(),
-      uuid: options?.uuid ? options.uuid : uuidv7()
-    };
-    const addGeoipDisableProperty = options?.disableGeoip ?? this.disableGeoip;
-    if (addGeoipDisableProperty) {
-      if (!message.properties) message.properties = {};
-      message["properties"]["$geoip_disable"] = true;
-    }
-    if (message.distinctId) {
-      message.distinct_id = message.distinctId;
-      delete message.distinctId;
-    }
-    return message;
-  }
-  clearFlushTimer() {
-    if (this._flushTimer) {
-      clearTimeout(this._flushTimer);
-      this._flushTimer = void 0;
-    }
-  }
-  flushBackground() {
-    this.flush().catch(async (err) => {
-      await logFlushError(err);
-    });
-  }
-  async flush() {
-    const nextFlushPromise = allSettled([
-      this.flushPromise
-    ]).then(() => this._flush());
-    this.flushPromise = nextFlushPromise;
-    this.addPendingPromise(nextFlushPromise);
-    allSettled([
-      nextFlushPromise
-    ]).then(() => {
-      if (this.flushPromise === nextFlushPromise) this.flushPromise = null;
-    });
-    return nextFlushPromise;
-  }
-  getCustomHeaders() {
-    const customUserAgent = this.getCustomUserAgent();
-    const headers = {};
-    if (customUserAgent && "" !== customUserAgent) headers["User-Agent"] = customUserAgent;
-    return headers;
-  }
-  async _flush() {
-    this.clearFlushTimer();
-    await this._initPromise;
-    let queue = this.getPersistedProperty(types_PostHogPersistedProperty.Queue) || [];
-    if (!queue.length) return;
-    const sentMessages = [];
-    const originalQueueLength = queue.length;
-    while (queue.length > 0 && sentMessages.length < originalQueueLength) {
-      const batchItems = queue.slice(0, this.maxBatchSize);
-      const batchMessages = batchItems.map((item) => item.message);
-      const persistQueueChange = () => {
-        const refreshedQueue = this.getPersistedProperty(types_PostHogPersistedProperty.Queue) || [];
-        const newQueue = refreshedQueue.slice(batchItems.length);
-        this.setPersistedProperty(types_PostHogPersistedProperty.Queue, newQueue);
-        queue = newQueue;
-      };
-      const data = {
-        api_key: this.apiKey,
-        batch: batchMessages,
-        sent_at: currentISOTime()
-      };
-      if (this.historicalMigration) data.historical_migration = true;
-      const payload = JSON.stringify(data);
-      const url = `${this.host}/batch/`;
-      const gzippedPayload = this.disableCompression ? null : await gzipCompress(payload, this.isDebug);
-      const fetchOptions = {
-        method: "POST",
-        headers: {
-          ...this.getCustomHeaders(),
-          "Content-Type": "application/json",
-          ...null !== gzippedPayload && {
-            "Content-Encoding": "gzip"
-          }
-        },
-        body: gzippedPayload || payload
-      };
-      const retryOptions = {
-        retryCheck: (err) => {
-          if (isPostHogFetchContentTooLargeError(err)) return false;
-          return isPostHogFetchError(err);
-        }
-      };
-      try {
-        await this.fetchWithRetry(url, fetchOptions, retryOptions);
-      } catch (err) {
-        if (isPostHogFetchContentTooLargeError(err) && batchMessages.length > 1) {
-          this.maxBatchSize = Math.max(1, Math.floor(batchMessages.length / 2));
-          this._logger.warn(`Received 413 when sending batch of size ${batchMessages.length}, reducing batch size to ${this.maxBatchSize}`);
-          continue;
-        }
-        if (!(err instanceof PostHogFetchNetworkError)) persistQueueChange();
-        this._events.emit("error", err);
-        throw err;
-      }
-      persistQueueChange();
-      sentMessages.push(...batchMessages);
-    }
-    this._events.emit("flush", sentMessages);
-  }
-  async fetchWithRetry(url, options, retryOptions, requestTimeout) {
-    AbortSignal.timeout ??= function(ms) {
-      const ctrl = new AbortController();
-      setTimeout(() => ctrl.abort(), ms);
-      return ctrl.signal;
-    };
-    const body = options.body ? options.body : "";
-    let reqByteLength = -1;
-    try {
-      reqByteLength = body instanceof Blob ? body.size : Buffer.byteLength(body, STRING_FORMAT);
-    } catch {
-      if (body instanceof Blob) reqByteLength = body.size;
-      else {
-        const encoded = new TextEncoder().encode(body);
-        reqByteLength = encoded.length;
-      }
-    }
-    return await retriable(async () => {
-      let res = null;
-      try {
-        res = await this.fetch(url, {
-          signal: AbortSignal.timeout(requestTimeout ?? this.requestTimeout),
-          ...options
-        });
-      } catch (e) {
-        throw new PostHogFetchNetworkError(e);
-      }
-      const isNoCors = "no-cors" === options.mode;
-      if (!isNoCors && (res.status < 200 || res.status >= 400)) throw new PostHogFetchHttpError(res, reqByteLength);
-      return res;
-    }, {
-      ...this._retryOptions,
-      ...retryOptions
-    });
-  }
-  async _shutdown(shutdownTimeoutMs = 3e4) {
-    await this._initPromise;
-    let hasTimedOut = false;
-    this.clearFlushTimer();
-    const doShutdown = async () => {
-      try {
-        await this.promiseQueue.join();
-        while (true) {
-          const queue = this.getPersistedProperty(types_PostHogPersistedProperty.Queue) || [];
-          if (0 === queue.length) break;
-          await this.flush();
-          if (hasTimedOut) break;
-        }
-      } catch (e) {
-        if (!isPostHogFetchError(e)) throw e;
-        await logFlushError(e);
-      }
-    };
-    return Promise.race([
-      new Promise((_, reject) => {
-        safeSetTimeout(() => {
-          this._logger.error("Timed out while shutting down PostHog");
-          hasTimedOut = true;
-          reject("Timeout while shutting down PostHog. Some events may not have been sent.");
-        }, shutdownTimeoutMs);
-      }),
-      doShutdown()
-    ]);
-  }
-  async shutdown(shutdownTimeoutMs = 3e4) {
-    if (this.shutdownPromise) this._logger.warn("shutdown() called while already shutting down. shutdown() is meant to be called once before process exit - use flush() for per-request cleanup");
-    else this.shutdownPromise = this._shutdown(shutdownTimeoutMs).finally(() => {
-      this.shutdownPromise = null;
-    });
-    return this.shutdownPromise;
-  }
-}
-let parsedStackResults;
-let lastKeysCount;
-let cachedFilenameChunkIds;
-function getFilenameToChunkIdMap(stackParser) {
-  const chunkIdMap = globalThis._posthogChunkIds;
-  if (!chunkIdMap) return;
-  const chunkIdKeys = Object.keys(chunkIdMap);
-  if (cachedFilenameChunkIds && chunkIdKeys.length === lastKeysCount) return cachedFilenameChunkIds;
-  lastKeysCount = chunkIdKeys.length;
-  cachedFilenameChunkIds = chunkIdKeys.reduce((acc, stackKey) => {
-    if (!parsedStackResults) parsedStackResults = {};
-    const result = parsedStackResults[stackKey];
-    if (result) acc[result[0]] = result[1];
-    else {
-      const parsedStack = stackParser(stackKey);
-      for (let i = parsedStack.length - 1; i >= 0; i--) {
-        const stackFrame = parsedStack[i];
-        const filename = stackFrame?.filename;
-        const chunkId = chunkIdMap[stackKey];
-        if (filename && chunkId) {
-          acc[filename] = chunkId;
-          parsedStackResults[stackKey] = [
-            filename,
-            chunkId
-          ];
-          break;
-        }
-      }
-    }
-    return acc;
-  }, {});
-  return cachedFilenameChunkIds;
-}
-const MAX_CAUSE_RECURSION = 4;
-class ErrorPropertiesBuilder {
-  constructor(coercers, stackParser, modifiers = []) {
-    this.coercers = coercers;
-    this.stackParser = stackParser;
-    this.modifiers = modifiers;
-  }
-  buildFromUnknown(input, hint = {}) {
-    const providedMechanism = hint && hint.mechanism;
-    const mechanism = providedMechanism || {
-      handled: true,
-      type: "generic"
-    };
-    const coercingContext = this.buildCoercingContext(mechanism, hint, 0);
-    const exceptionWithCause = coercingContext.apply(input);
-    const parsingContext = this.buildParsingContext();
-    const exceptionWithStack = this.parseStacktrace(exceptionWithCause, parsingContext);
-    const exceptionList = this.convertToExceptionList(exceptionWithStack, mechanism);
-    return {
-      $exception_list: exceptionList,
-      $exception_level: "error"
-    };
-  }
-  async modifyFrames(exceptionList) {
-    for (const exc of exceptionList) if (exc.stacktrace && exc.stacktrace.frames && isArray(exc.stacktrace.frames)) exc.stacktrace.frames = await this.applyModifiers(exc.stacktrace.frames);
-    return exceptionList;
-  }
-  coerceFallback(ctx) {
-    return {
-      type: "Error",
-      value: "Unknown error",
-      stack: ctx.syntheticException?.stack,
-      synthetic: true
-    };
-  }
-  parseStacktrace(err, ctx) {
-    let cause;
-    if (null != err.cause) cause = this.parseStacktrace(err.cause, ctx);
-    let stack;
-    if ("" != err.stack && null != err.stack) stack = this.applyChunkIds(this.stackParser(err.stack, err.synthetic ? 1 : 0), ctx.chunkIdMap);
-    return {
-      ...err,
-      cause,
-      stack
-    };
-  }
-  applyChunkIds(frames, chunkIdMap) {
-    return frames.map((frame) => {
-      if (frame.filename && chunkIdMap) frame.chunk_id = chunkIdMap[frame.filename];
-      return frame;
-    });
-  }
-  applyCoercers(input, ctx) {
-    for (const adapter of this.coercers) if (adapter.match(input)) return adapter.coerce(input, ctx);
-    return this.coerceFallback(ctx);
-  }
-  async applyModifiers(frames) {
-    let newFrames = frames;
-    for (const modifier of this.modifiers) newFrames = await modifier(newFrames);
-    return newFrames;
-  }
-  convertToExceptionList(exceptionWithStack, mechanism) {
-    const currentException = {
-      type: exceptionWithStack.type,
-      value: exceptionWithStack.value,
-      mechanism: {
-        type: mechanism.type ?? "generic",
-        handled: mechanism.handled ?? true,
-        synthetic: exceptionWithStack.synthetic ?? false
-      }
-    };
-    if (exceptionWithStack.stack) currentException.stacktrace = {
-      type: "raw",
-      frames: exceptionWithStack.stack
-    };
-    const exceptionList = [
-      currentException
-    ];
-    if (null != exceptionWithStack.cause) exceptionList.push(...this.convertToExceptionList(exceptionWithStack.cause, {
-      ...mechanism,
-      handled: true
-    }));
-    return exceptionList;
-  }
-  buildParsingContext() {
-    const context = {
-      chunkIdMap: getFilenameToChunkIdMap(this.stackParser)
-    };
-    return context;
-  }
-  buildCoercingContext(mechanism, hint, depth = 0) {
-    const coerce = (input, depth2) => {
-      if (!(depth2 <= MAX_CAUSE_RECURSION)) return;
-      {
-        const ctx = this.buildCoercingContext(mechanism, hint, depth2);
-        return this.applyCoercers(input, ctx);
-      }
-    };
-    const context = {
-      ...hint,
-      syntheticException: 0 == depth ? hint.syntheticException : void 0,
-      mechanism,
-      apply: (input) => coerce(input, depth),
-      next: (input) => coerce(input, depth + 1)
-    };
-    return context;
-  }
-}
-const UNKNOWN_FUNCTION = "?";
-const FILENAME_MATCH = /^\s*[-]{4,}$/;
-const FULL_MATCH = /at (?:async )?(?:(.+?)\s+\()?(?:(.+):(\d+):(\d+)?|([^)]+))\)?/;
-const nodeStackLineParser = (line, platform) => {
-  const lineMatch = line.match(FULL_MATCH);
-  if (lineMatch) {
-    let object;
-    let method;
-    let functionName;
-    let typeName;
-    let methodName;
-    if (lineMatch[1]) {
-      functionName = lineMatch[1];
-      let methodStart = functionName.lastIndexOf(".");
-      if ("." === functionName[methodStart - 1]) methodStart--;
-      if (methodStart > 0) {
-        object = functionName.slice(0, methodStart);
-        method = functionName.slice(methodStart + 1);
-        const objectEnd = object.indexOf(".Module");
-        if (objectEnd > 0) {
-          functionName = functionName.slice(objectEnd + 1);
-          object = object.slice(0, objectEnd);
-        }
-      }
-      typeName = void 0;
-    }
-    if (method) {
-      typeName = object;
-      methodName = method;
-    }
-    if ("<anonymous>" === method) {
-      methodName = void 0;
-      functionName = void 0;
-    }
-    if (void 0 === functionName) {
-      methodName = methodName || UNKNOWN_FUNCTION;
-      functionName = typeName ? `${typeName}.${methodName}` : methodName;
-    }
-    let filename = lineMatch[2]?.startsWith("file://") ? lineMatch[2].slice(7) : lineMatch[2];
-    const isNative = "native" === lineMatch[5];
-    if (filename?.match(/\/[A-Z]:/)) filename = filename.slice(1);
-    if (!filename && lineMatch[5] && !isNative) filename = lineMatch[5];
-    return {
-      filename: filename ? decodeURI(filename) : void 0,
-      module: void 0,
-      function: functionName,
-      lineno: _parseIntOrUndefined(lineMatch[3]),
-      colno: _parseIntOrUndefined(lineMatch[4]),
-      in_app: filenameIsInApp(filename || "", isNative),
-      platform
-    };
-  }
-  if (line.match(FILENAME_MATCH)) return {
-    filename: line,
-    platform
-  };
-};
-function filenameIsInApp(filename, isNative = false) {
-  const isInternal = isNative || filename && !filename.startsWith("/") && !filename.match(/^[A-Z]:/) && !filename.startsWith(".") && !filename.match(/^[a-zA-Z]([a-zA-Z0-9.\-+])*:\/\//);
-  return !isInternal && void 0 !== filename && !filename.includes("node_modules/");
-}
-function _parseIntOrUndefined(input) {
-  return parseInt(input || "", 10) || void 0;
-}
-const WEBPACK_ERROR_REGEXP = /\(error: (.*)\)/;
-const STACKTRACE_FRAME_LIMIT = 50;
-function reverseAndStripFrames(stack) {
-  if (!stack.length) return [];
-  const localStack = Array.from(stack);
-  localStack.reverse();
-  return localStack.slice(0, STACKTRACE_FRAME_LIMIT).map((frame) => ({
-    ...frame,
-    filename: frame.filename || getLastStackFrame(localStack).filename,
-    function: frame.function || UNKNOWN_FUNCTION
-  }));
-}
-function getLastStackFrame(arr) {
-  return arr[arr.length - 1] || {};
-}
-function createStackParser(platform, ...parsers) {
-  return (stack, skipFirstLines = 0) => {
-    const frames = [];
-    const lines = stack.split("\n");
-    for (let i = skipFirstLines; i < lines.length; i++) {
-      const line = lines[i];
-      if (line.length > 1024) continue;
-      const cleanedLine = WEBPACK_ERROR_REGEXP.test(line) ? line.replace(WEBPACK_ERROR_REGEXP, "$1") : line;
-      if (!cleanedLine.match(/\S*Error: /)) {
-        for (const parser of parsers) {
-          const frame = parser(cleanedLine, platform);
-          if (frame) {
-            frames.push(frame);
-            break;
-          }
-        }
-        if (frames.length >= STACKTRACE_FRAME_LIMIT) break;
-      }
-    }
-    return reverseAndStripFrames(frames);
-  };
-}
-class ErrorCoercer {
-  match(err) {
-    return isPlainError(err);
-  }
-  coerce(err, ctx) {
-    return {
-      type: this.getType(err),
-      value: this.getMessage(err, ctx),
-      stack: this.getStack(err),
-      cause: err.cause ? ctx.next(err.cause) : void 0,
-      synthetic: false
-    };
-  }
-  getType(err) {
-    return err.name || err.constructor.name;
-  }
-  getMessage(err, _ctx) {
-    const message = err.message;
-    if (message.error && "string" == typeof message.error.message) return String(message.error.message);
-    return String(message);
-  }
-  getStack(err) {
-    return err.stacktrace || err.stack || void 0;
-  }
-}
-const ERROR_TYPES_PATTERN = /^(?:[Uu]ncaught (?:exception: )?)?(?:((?:Eval|Internal|Range|Reference|Syntax|Type|URI|)Error): )?(.*)$/i;
-class StringCoercer {
-  match(input) {
-    return "string" == typeof input;
-  }
-  coerce(input, ctx) {
-    const [type, value] = this.getInfos(input);
-    return {
-      type: type ?? "Error",
-      value: value ?? input,
-      stack: ctx.syntheticException?.stack,
-      synthetic: true
-    };
-  }
-  getInfos(candidate) {
-    let type = "Error";
-    let value = candidate;
-    const groups = candidate.match(ERROR_TYPES_PATTERN);
-    if (groups) {
-      type = groups[1];
-      value = groups[2];
-    }
-    return [
-      type,
-      value
-    ];
-  }
-}
-const severityLevels = [
-  "fatal",
-  "error",
-  "warning",
-  "log",
-  "info",
-  "debug"
-];
-function extractExceptionKeysForMessage(err, maxLength = 40) {
-  const keys = Object.keys(err);
-  keys.sort();
-  if (!keys.length) return "[object has no keys]";
-  for (let i = keys.length; i > 0; i--) {
-    const serialized = keys.slice(0, i).join(", ");
-    if (!(serialized.length > maxLength)) {
-      if (i === keys.length) return serialized;
-      return serialized.length <= maxLength ? serialized : `${serialized.slice(0, maxLength)}...`;
-    }
-  }
-  return "";
-}
-class ObjectCoercer {
-  match(candidate) {
-    return "object" == typeof candidate && null !== candidate;
-  }
-  coerce(candidate, ctx) {
-    const errorProperty = this.getErrorPropertyFromObject(candidate);
-    if (errorProperty) return ctx.apply(errorProperty);
-    return {
-      type: this.getType(candidate),
-      value: this.getValue(candidate),
-      stack: ctx.syntheticException?.stack,
-      level: this.isSeverityLevel(candidate.level) ? candidate.level : "error",
-      synthetic: true
-    };
-  }
-  getType(err) {
-    return isEvent(err) ? err.constructor.name : "Error";
-  }
-  getValue(err) {
-    if ("name" in err && "string" == typeof err.name) {
-      let message = `'${err.name}' captured as exception`;
-      if ("message" in err && "string" == typeof err.message) message += ` with message: '${err.message}'`;
-      return message;
-    }
-    if ("message" in err && "string" == typeof err.message) return err.message;
-    const className = this.getObjectClassName(err);
-    const keys = extractExceptionKeysForMessage(err);
-    return `${className && "Object" !== className ? `'${className}'` : "Object"} captured as exception with keys: ${keys}`;
-  }
-  isSeverityLevel(x) {
-    return isString(x) && !isEmptyString(x) && severityLevels.indexOf(x) >= 0;
-  }
-  getErrorPropertyFromObject(obj) {
-    for (const prop in obj) if (Object.prototype.hasOwnProperty.call(obj, prop)) {
-      const value = obj[prop];
-      if (isError(value)) return value;
-    }
-  }
-  getObjectClassName(obj) {
-    try {
-      const prototype = Object.getPrototypeOf(obj);
-      return prototype ? prototype.constructor.name : void 0;
-    } catch (e) {
-      return;
-    }
-  }
-}
-class EventCoercer {
-  match(err) {
-    return isEvent(err);
-  }
-  coerce(evt, ctx) {
-    const constructorName = evt.constructor.name;
-    return {
-      type: constructorName,
-      value: `${constructorName} captured as exception with keys: ${extractExceptionKeysForMessage(evt)}`,
-      stack: ctx.syntheticException?.stack,
-      synthetic: true
-    };
-  }
-}
-class PrimitiveCoercer {
-  match(candidate) {
-    return isPrimitive(candidate);
-  }
-  coerce(value, ctx) {
-    return {
-      type: "Error",
-      value: `Primitive value captured as exception: ${String(value)}`,
-      stack: ctx.syntheticException?.stack,
-      synthetic: true
-    };
-  }
-}
-class ReduceableCache {
-  constructor(_maxSize) {
-    this._maxSize = _maxSize;
-    this._cache = /* @__PURE__ */ new Map();
-  }
-  get(key) {
-    const value = this._cache.get(key);
-    if (void 0 === value) return;
-    this._cache.delete(key);
-    this._cache.set(key, value);
-    return value;
-  }
-  set(key, value) {
-    this._cache.set(key, value);
-  }
-  reduce() {
-    while (this._cache.size >= this._maxSize) {
-      const value = this._cache.keys().next().value;
-      if (value) this._cache.delete(value);
-    }
-  }
-}
-const LRU_FILE_CONTENTS_CACHE = new ReduceableCache(25);
-const LRU_FILE_CONTENTS_FS_READ_FAILED = new ReduceableCache(20);
-const DEFAULT_LINES_OF_CONTEXT = 7;
-const MAX_CONTEXTLINES_COLNO = 1e3;
-const MAX_CONTEXTLINES_LINENO = 1e4;
-async function addSourceContext(frames) {
-  const filesToLines = {};
-  for (let i = frames.length - 1; i >= 0; i--) {
-    const frame = frames[i];
-    const filename = frame?.filename;
-    if (!frame || "string" != typeof filename || "number" != typeof frame.lineno || shouldSkipContextLinesForFile(filename) || shouldSkipContextLinesForFrame(frame)) continue;
-    const filesToLinesOutput = filesToLines[filename];
-    if (!filesToLinesOutput) filesToLines[filename] = [];
-    filesToLines[filename].push(frame.lineno);
-  }
-  const files = Object.keys(filesToLines);
-  if (0 == files.length) return frames;
-  const readlinePromises = [];
-  for (const file of files) {
-    if (LRU_FILE_CONTENTS_FS_READ_FAILED.get(file)) continue;
-    const filesToLineRanges = filesToLines[file];
-    if (!filesToLineRanges) continue;
-    filesToLineRanges.sort((a, b) => a - b);
-    const ranges = makeLineReaderRanges(filesToLineRanges);
-    if (ranges.every((r) => rangeExistsInContentCache(file, r))) continue;
-    const cache = emplace(LRU_FILE_CONTENTS_CACHE, file, {});
-    readlinePromises.push(getContextLinesFromFile(file, ranges, cache));
-  }
-  await Promise.all(readlinePromises).catch(() => {
-  });
-  if (frames && frames.length > 0) addSourceContextToFrames(frames, LRU_FILE_CONTENTS_CACHE);
-  LRU_FILE_CONTENTS_CACHE.reduce();
-  return frames;
-}
-function getContextLinesFromFile(path2, ranges, output) {
-  return new Promise((resolve) => {
-    const stream = createReadStream(path2);
-    const lineReaded = createInterface({
-      input: stream
-    });
-    function destroyStreamAndResolve() {
-      stream.destroy();
-      resolve();
-    }
-    let lineNumber = 0;
-    let currentRangeIndex = 0;
-    const range = ranges[currentRangeIndex];
-    if (void 0 === range) return void destroyStreamAndResolve();
-    let rangeStart = range[0];
-    let rangeEnd = range[1];
-    function onStreamError() {
-      LRU_FILE_CONTENTS_FS_READ_FAILED.set(path2, 1);
-      lineReaded.close();
-      lineReaded.removeAllListeners();
-      destroyStreamAndResolve();
-    }
-    stream.on("error", onStreamError);
-    lineReaded.on("error", onStreamError);
-    lineReaded.on("close", destroyStreamAndResolve);
-    lineReaded.on("line", (line) => {
-      lineNumber++;
-      if (lineNumber < rangeStart) return;
-      output[lineNumber] = snipLine(line, 0);
-      if (lineNumber >= rangeEnd) {
-        if (currentRangeIndex === ranges.length - 1) {
-          lineReaded.close();
-          lineReaded.removeAllListeners();
-          return;
-        }
-        currentRangeIndex++;
-        const range2 = ranges[currentRangeIndex];
-        if (void 0 === range2) {
-          lineReaded.close();
-          lineReaded.removeAllListeners();
-          return;
-        }
-        rangeStart = range2[0];
-        rangeEnd = range2[1];
-      }
-    });
-  });
-}
-function addSourceContextToFrames(frames, cache) {
-  for (const frame of frames) if (frame.filename && void 0 === frame.context_line && "number" == typeof frame.lineno) {
-    const contents = cache.get(frame.filename);
-    if (void 0 === contents) continue;
-    addContextToFrame(frame.lineno, frame, contents);
-  }
-}
-function addContextToFrame(lineno, frame, contents) {
-  if (void 0 === frame.lineno || void 0 === contents) return;
-  frame.pre_context = [];
-  for (let i = makeRangeStart(lineno); i < lineno; i++) {
-    const line = contents[i];
-    if (void 0 === line) return void clearLineContext(frame);
-    frame.pre_context.push(line);
-  }
-  if (void 0 === contents[lineno]) return void clearLineContext(frame);
-  frame.context_line = contents[lineno];
-  const end = makeRangeEnd(lineno);
-  frame.post_context = [];
-  for (let i = lineno + 1; i <= end; i++) {
-    const line = contents[i];
-    if (void 0 === line) break;
-    frame.post_context.push(line);
-  }
-}
-function clearLineContext(frame) {
-  delete frame.pre_context;
-  delete frame.context_line;
-  delete frame.post_context;
-}
-function shouldSkipContextLinesForFile(path2) {
-  return path2.startsWith("node:") || path2.endsWith(".min.js") || path2.endsWith(".min.cjs") || path2.endsWith(".min.mjs") || path2.startsWith("data:");
-}
-function shouldSkipContextLinesForFrame(frame) {
-  if (void 0 !== frame.lineno && frame.lineno > MAX_CONTEXTLINES_LINENO) return true;
-  if (void 0 !== frame.colno && frame.colno > MAX_CONTEXTLINES_COLNO) return true;
-  return false;
-}
-function rangeExistsInContentCache(file, range) {
-  const contents = LRU_FILE_CONTENTS_CACHE.get(file);
-  if (void 0 === contents) return false;
-  for (let i = range[0]; i <= range[1]; i++) if (void 0 === contents[i]) return false;
-  return true;
-}
-function makeLineReaderRanges(lines) {
-  if (!lines.length) return [];
-  let i = 0;
-  const line = lines[0];
-  if ("number" != typeof line) return [];
-  let current = makeContextRange(line);
-  const out = [];
-  while (true) {
-    if (i === lines.length - 1) {
-      out.push(current);
-      break;
-    }
-    const next = lines[i + 1];
-    if ("number" != typeof next) break;
-    if (next <= current[1]) current[1] = next + DEFAULT_LINES_OF_CONTEXT;
-    else {
-      out.push(current);
-      current = makeContextRange(next);
-    }
-    i++;
-  }
-  return out;
-}
-function makeContextRange(line) {
-  return [
-    makeRangeStart(line),
-    makeRangeEnd(line)
-  ];
-}
-function makeRangeStart(line) {
-  return Math.max(1, line - DEFAULT_LINES_OF_CONTEXT);
-}
-function makeRangeEnd(line) {
-  return line + DEFAULT_LINES_OF_CONTEXT;
-}
-function emplace(map, key, contents) {
-  const value = map.get(key);
-  if (void 0 === value) {
-    map.set(key, contents);
-    return contents;
-  }
-  return value;
-}
-function snipLine(line, colno) {
-  let newLine = line;
-  const lineLength = newLine.length;
-  if (lineLength <= 150) return newLine;
-  if (colno > lineLength) colno = lineLength;
-  let start = Math.max(colno - 60, 0);
-  if (start < 5) start = 0;
-  let end = Math.min(start + 140, lineLength);
-  if (end > lineLength - 5) end = lineLength;
-  if (end === lineLength) start = Math.max(end - 140, 0);
-  newLine = newLine.slice(start, end);
-  if (start > 0) newLine = `...${newLine}`;
-  if (end < lineLength) newLine += "...";
-  return newLine;
-}
-function makeUncaughtExceptionHandler(captureFn, onFatalFn) {
-  let calledFatalError = false;
-  return Object.assign((error) => {
-    const userProvidedListenersCount = global.process.listeners("uncaughtException").filter((listener) => "domainUncaughtExceptionClear" !== listener.name && true !== listener._posthogErrorHandler).length;
-    const processWouldExit = 0 === userProvidedListenersCount;
-    captureFn(error, {
-      mechanism: {
-        type: "onuncaughtexception",
-        handled: false
-      }
-    });
-    if (!calledFatalError && processWouldExit) {
-      calledFatalError = true;
-      onFatalFn(error);
-    }
-  }, {
-    _posthogErrorHandler: true
-  });
-}
-function addUncaughtExceptionListener(captureFn, onFatalFn) {
-  globalThis.process?.on("uncaughtException", makeUncaughtExceptionHandler(captureFn, onFatalFn));
-}
-function addUnhandledRejectionListener(captureFn) {
-  globalThis.process?.on("unhandledRejection", (reason) => captureFn(reason, {
-    mechanism: {
-      type: "onunhandledrejection",
-      handled: false
-    }
-  }));
-}
-const SHUTDOWN_TIMEOUT = 2e3;
-class ErrorTracking {
-  constructor(client2, options, _logger) {
-    this.client = client2;
-    this._exceptionAutocaptureEnabled = options.enableExceptionAutocapture || false;
-    this._logger = _logger;
-    this._rateLimiter = new BucketedRateLimiter({
-      refillRate: 1,
-      bucketSize: 10,
-      refillInterval: 1e4,
-      _logger: this._logger
-    });
-    this.startAutocaptureIfEnabled();
-  }
-  static isPreviouslyCapturedError(x) {
-    return isObject(x) && "__posthog_previously_captured_error" in x && true === x.__posthog_previously_captured_error;
-  }
-  static async buildEventMessage(error, hint, distinctId, additionalProperties) {
-    const properties = {
-      ...additionalProperties
-    };
-    if (!distinctId) properties.$process_person_profile = false;
-    const exceptionProperties = this.errorPropertiesBuilder.buildFromUnknown(error, hint);
-    exceptionProperties.$exception_list = await this.errorPropertiesBuilder.modifyFrames(exceptionProperties.$exception_list);
-    return {
-      event: "$exception",
-      distinctId: distinctId || uuidv7(),
-      properties: {
-        ...exceptionProperties,
-        ...properties
-      }
-    };
-  }
-  startAutocaptureIfEnabled() {
-    if (this.isEnabled()) {
-      addUncaughtExceptionListener(this.onException.bind(this), this.onFatalError.bind(this));
-      addUnhandledRejectionListener(this.onException.bind(this));
-    }
-  }
-  onException(exception, hint) {
-    this.client.addPendingPromise((async () => {
-      if (!ErrorTracking.isPreviouslyCapturedError(exception)) {
-        const eventMessage = await ErrorTracking.buildEventMessage(exception, hint);
-        const exceptionProperties = eventMessage.properties;
-        const exceptionType = exceptionProperties?.$exception_list[0]?.type ?? "Exception";
-        const isRateLimited = this._rateLimiter.consumeRateLimit(exceptionType);
-        if (isRateLimited) return void this._logger.info("Skipping exception capture because of client rate limiting.", {
-          exception: exceptionType
-        });
-        return this.client.capture(eventMessage);
-      }
-    })());
-  }
-  async onFatalError(exception) {
-    console.error(exception);
-    await this.client.shutdown(SHUTDOWN_TIMEOUT);
-    process.exit(1);
-  }
-  isEnabled() {
-    return !this.client.isDisabled && this._exceptionAutocaptureEnabled;
-  }
-  shutdown() {
-    this._rateLimiter.stop();
-  }
-}
-const version = "5.20.0";
-const FeatureFlagError = {
-  ERRORS_WHILE_COMPUTING: "errors_while_computing_flags",
-  FLAG_MISSING: "flag_missing",
-  QUOTA_LIMITED: "quota_limited",
-  UNKNOWN_ERROR: "unknown_error"
-};
-async function hashSHA1(text) {
-  const subtle = globalThis.crypto?.subtle;
-  if (!subtle) throw new Error("SubtleCrypto API not available");
-  const hashBuffer = await subtle.digest("SHA-1", new TextEncoder().encode(text));
-  const hashArray = Array.from(new Uint8Array(hashBuffer));
-  return hashArray.map((byte) => byte.toString(16).padStart(2, "0")).join("");
-}
-const SIXTY_SECONDS = 6e4;
-const LONG_SCALE = 1152921504606847e3;
-const NULL_VALUES_ALLOWED_OPERATORS = [
-  "is_not"
-];
-class ClientError extends Error {
-  constructor(message) {
-    super();
-    Error.captureStackTrace(this, this.constructor);
-    this.name = "ClientError";
-    this.message = message;
-    Object.setPrototypeOf(this, ClientError.prototype);
-  }
-}
-class InconclusiveMatchError extends Error {
-  constructor(message) {
-    super(message);
-    this.name = this.constructor.name;
-    Error.captureStackTrace(this, this.constructor);
-    Object.setPrototypeOf(this, InconclusiveMatchError.prototype);
-  }
-}
-class RequiresServerEvaluation extends Error {
-  constructor(message) {
-    super(message);
-    this.name = this.constructor.name;
-    Error.captureStackTrace(this, this.constructor);
-    Object.setPrototypeOf(this, RequiresServerEvaluation.prototype);
-  }
-}
-class FeatureFlagsPoller {
-  constructor({ pollingInterval, personalApiKey, projectApiKey, timeout, host, customHeaders, ...options }) {
-    this.debugMode = false;
-    this.shouldBeginExponentialBackoff = false;
-    this.backOffCount = 0;
-    this.pollingInterval = pollingInterval;
-    this.personalApiKey = personalApiKey;
-    this.featureFlags = [];
-    this.featureFlagsByKey = {};
-    this.groupTypeMapping = {};
-    this.cohorts = {};
-    this.loadedSuccessfullyOnce = false;
-    this.timeout = timeout;
-    this.projectApiKey = projectApiKey;
-    this.host = host;
-    this.poller = void 0;
-    this.fetch = options.fetch || fetch;
-    this.onError = options.onError;
-    this.customHeaders = customHeaders;
-    this.onLoad = options.onLoad;
-    this.cacheProvider = options.cacheProvider;
-    this.loadFeatureFlags();
-  }
-  debug(enabled = true) {
-    this.debugMode = enabled;
-  }
-  logMsgIfDebug(fn) {
-    if (this.debugMode) fn();
-  }
-  async getFeatureFlag(key, distinctId, groups = {}, personProperties = {}, groupProperties = {}) {
-    await this.loadFeatureFlags();
-    let response;
-    let featureFlag;
-    if (!this.loadedSuccessfullyOnce) return response;
-    featureFlag = this.featureFlagsByKey[key];
-    if (void 0 !== featureFlag) try {
-      const result = await this.computeFlagAndPayloadLocally(featureFlag, distinctId, groups, personProperties, groupProperties);
-      response = result.value;
-      this.logMsgIfDebug(() => console.debug(`Successfully computed flag locally: ${key} -> ${response}`));
-    } catch (e) {
-      if (e instanceof RequiresServerEvaluation || e instanceof InconclusiveMatchError) this.logMsgIfDebug(() => console.debug(`${e.name} when computing flag locally: ${key}: ${e.message}`));
-      else if (e instanceof Error) this.onError?.(new Error(`Error computing flag locally: ${key}: ${e}`));
-    }
-    return response;
-  }
-  async getAllFlagsAndPayloads(distinctId, groups = {}, personProperties = {}, groupProperties = {}, flagKeysToExplicitlyEvaluate) {
-    await this.loadFeatureFlags();
-    const response = {};
-    const payloads = {};
-    let fallbackToFlags = 0 == this.featureFlags.length;
-    const flagsToEvaluate = flagKeysToExplicitlyEvaluate ? flagKeysToExplicitlyEvaluate.map((key) => this.featureFlagsByKey[key]).filter(Boolean) : this.featureFlags;
-    const sharedEvaluationCache = {};
-    await Promise.all(flagsToEvaluate.map(async (flag) => {
-      try {
-        const { value: matchValue, payload: matchPayload } = await this.computeFlagAndPayloadLocally(flag, distinctId, groups, personProperties, groupProperties, void 0, sharedEvaluationCache);
-        response[flag.key] = matchValue;
-        if (matchPayload) payloads[flag.key] = matchPayload;
-      } catch (e) {
-        if (e instanceof RequiresServerEvaluation || e instanceof InconclusiveMatchError) this.logMsgIfDebug(() => console.debug(`${e.name} when computing flag locally: ${flag.key}: ${e.message}`));
-        else if (e instanceof Error) this.onError?.(new Error(`Error computing flag locally: ${flag.key}: ${e}`));
-        fallbackToFlags = true;
-      }
-    }));
-    return {
-      response,
-      payloads,
-      fallbackToFlags
-    };
-  }
-  async computeFlagAndPayloadLocally(flag, distinctId, groups = {}, personProperties = {}, groupProperties = {}, matchValue, evaluationCache, skipLoadCheck = false) {
-    if (!skipLoadCheck) await this.loadFeatureFlags();
-    if (!this.loadedSuccessfullyOnce) return {
-      value: false,
-      payload: null
-    };
-    let flagValue;
-    flagValue = void 0 !== matchValue ? matchValue : await this.computeFlagValueLocally(flag, distinctId, groups, personProperties, groupProperties, evaluationCache);
-    const payload = this.getFeatureFlagPayload(flag.key, flagValue);
-    return {
-      value: flagValue,
-      payload
-    };
-  }
-  async computeFlagValueLocally(flag, distinctId, groups = {}, personProperties = {}, groupProperties = {}, evaluationCache = {}) {
-    if (flag.ensure_experience_continuity) throw new InconclusiveMatchError("Flag has experience continuity enabled");
-    if (!flag.active) return false;
-    const flagFilters = flag.filters || {};
-    const aggregation_group_type_index = flagFilters.aggregation_group_type_index;
-    if (void 0 == aggregation_group_type_index) return await this.matchFeatureFlagProperties(flag, distinctId, personProperties, evaluationCache);
-    {
-      const groupName = this.groupTypeMapping[String(aggregation_group_type_index)];
-      if (!groupName) {
-        this.logMsgIfDebug(() => console.warn(`[FEATURE FLAGS] Unknown group type index ${aggregation_group_type_index} for feature flag ${flag.key}`));
-        throw new InconclusiveMatchError("Flag has unknown group type index");
-      }
-      if (!(groupName in groups)) {
-        this.logMsgIfDebug(() => console.warn(`[FEATURE FLAGS] Can't compute group feature flag: ${flag.key} without group names passed in`));
-        return false;
-      }
-      const focusedGroupProperties = groupProperties[groupName];
-      return await this.matchFeatureFlagProperties(flag, groups[groupName], focusedGroupProperties, evaluationCache);
-    }
-  }
-  getFeatureFlagPayload(key, flagValue) {
-    let payload = null;
-    if (false !== flagValue && null != flagValue) {
-      if ("boolean" == typeof flagValue) payload = this.featureFlagsByKey?.[key]?.filters?.payloads?.[flagValue.toString()] || null;
-      else if ("string" == typeof flagValue) payload = this.featureFlagsByKey?.[key]?.filters?.payloads?.[flagValue] || null;
-      if (null != payload) {
-        if ("object" == typeof payload) return payload;
-        if ("string" == typeof payload) try {
-          return JSON.parse(payload);
-        } catch {
-        }
-        return payload;
-      }
-    }
-    return null;
-  }
-  async evaluateFlagDependency(property, distinctId, properties, evaluationCache) {
-    const targetFlagKey = property.key;
-    if (!this.featureFlagsByKey) throw new InconclusiveMatchError("Feature flags not available for dependency evaluation");
-    if (!("dependency_chain" in property)) throw new InconclusiveMatchError(`Flag dependency property for '${targetFlagKey}' is missing required 'dependency_chain' field`);
-    const dependencyChain = property.dependency_chain;
-    if (!Array.isArray(dependencyChain)) throw new InconclusiveMatchError(`Flag dependency property for '${targetFlagKey}' has an invalid 'dependency_chain' (expected array, got ${typeof dependencyChain})`);
-    if (0 === dependencyChain.length) throw new InconclusiveMatchError(`Circular dependency detected for flag '${targetFlagKey}' (empty dependency chain)`);
-    for (const depFlagKey of dependencyChain) {
-      if (!(depFlagKey in evaluationCache)) {
-        const depFlag = this.featureFlagsByKey[depFlagKey];
-        if (depFlag) if (depFlag.active) try {
-          const depResult = await this.matchFeatureFlagProperties(depFlag, distinctId, properties, evaluationCache);
-          evaluationCache[depFlagKey] = depResult;
-        } catch (error) {
-          throw new InconclusiveMatchError(`Error evaluating flag dependency '${depFlagKey}' for flag '${targetFlagKey}': ${error}`);
-        }
-        else evaluationCache[depFlagKey] = false;
-        else throw new InconclusiveMatchError(`Missing flag dependency '${depFlagKey}' for flag '${targetFlagKey}'`);
-      }
-      const cachedResult = evaluationCache[depFlagKey];
-      if (null == cachedResult) throw new InconclusiveMatchError(`Dependency '${depFlagKey}' could not be evaluated`);
-    }
-    const targetFlagValue = evaluationCache[targetFlagKey];
-    return this.flagEvaluatesToExpectedValue(property.value, targetFlagValue);
-  }
-  flagEvaluatesToExpectedValue(expectedValue, flagValue) {
-    if ("boolean" == typeof expectedValue) return expectedValue === flagValue || "string" == typeof flagValue && "" !== flagValue && true === expectedValue;
-    if ("string" == typeof expectedValue) return flagValue === expectedValue;
-    return false;
-  }
-  async matchFeatureFlagProperties(flag, distinctId, properties, evaluationCache = {}) {
-    const flagFilters = flag.filters || {};
-    const flagConditions = flagFilters.groups || [];
-    let isInconclusive = false;
-    let result;
-    for (const condition of flagConditions) try {
-      if (await this.isConditionMatch(flag, distinctId, condition, properties, evaluationCache)) {
-        const variantOverride = condition.variant;
-        const flagVariants = flagFilters.multivariate?.variants || [];
-        result = variantOverride && flagVariants.some((variant) => variant.key === variantOverride) ? variantOverride : await this.getMatchingVariant(flag, distinctId) || true;
-        break;
-      }
-    } catch (e) {
-      if (e instanceof RequiresServerEvaluation) throw e;
-      if (e instanceof InconclusiveMatchError) isInconclusive = true;
-      else throw e;
-    }
-    if (void 0 !== result) return result;
-    if (isInconclusive) throw new InconclusiveMatchError("Can't determine if feature flag is enabled or not with given properties");
-    return false;
-  }
-  async isConditionMatch(flag, distinctId, condition, properties, evaluationCache = {}) {
-    const rolloutPercentage = condition.rollout_percentage;
-    const warnFunction = (msg) => {
-      this.logMsgIfDebug(() => console.warn(msg));
-    };
-    if ((condition.properties || []).length > 0) {
-      for (const prop of condition.properties) {
-        const propertyType = prop.type;
-        let matches = false;
-        matches = "cohort" === propertyType ? matchCohort(prop, properties, this.cohorts, this.debugMode) : "flag" === propertyType ? await this.evaluateFlagDependency(prop, distinctId, properties, evaluationCache) : matchProperty(prop, properties, warnFunction);
-        if (!matches) return false;
-      }
-      if (void 0 == rolloutPercentage) return true;
-    }
-    if (void 0 != rolloutPercentage && await _hash(flag.key, distinctId) > rolloutPercentage / 100) return false;
-    return true;
-  }
-  async getMatchingVariant(flag, distinctId) {
-    const hashValue = await _hash(flag.key, distinctId, "variant");
-    const matchingVariant = this.variantLookupTable(flag).find((variant) => hashValue >= variant.valueMin && hashValue < variant.valueMax);
-    if (matchingVariant) return matchingVariant.key;
-  }
-  variantLookupTable(flag) {
-    const lookupTable = [];
-    let valueMin = 0;
-    let valueMax = 0;
-    const flagFilters = flag.filters || {};
-    const multivariates = flagFilters.multivariate?.variants || [];
-    multivariates.forEach((variant) => {
-      valueMax = valueMin + variant.rollout_percentage / 100;
-      lookupTable.push({
-        valueMin,
-        valueMax,
-        key: variant.key
-      });
-      valueMin = valueMax;
-    });
-    return lookupTable;
-  }
-  updateFlagState(flagData) {
-    this.featureFlags = flagData.flags;
-    this.featureFlagsByKey = flagData.flags.reduce((acc, curr) => (acc[curr.key] = curr, acc), {});
-    this.groupTypeMapping = flagData.groupTypeMapping;
-    this.cohorts = flagData.cohorts;
-    this.loadedSuccessfullyOnce = true;
-  }
-  async loadFromCache(debugMessage) {
-    if (!this.cacheProvider) return false;
-    try {
-      const cached = await this.cacheProvider.getFlagDefinitions();
-      if (cached) {
-        this.updateFlagState(cached);
-        this.logMsgIfDebug(() => console.debug(`[FEATURE FLAGS] ${debugMessage} (${cached.flags.length} flags)`));
-        this.onLoad?.(this.featureFlags.length);
-        return true;
-      }
-      return false;
-    } catch (err) {
-      this.onError?.(new Error(`Failed to load from cache: ${err}`));
-      return false;
-    }
-  }
-  async loadFeatureFlags(forceReload = false) {
-    if (this.loadedSuccessfullyOnce && !forceReload) return;
-    if (!forceReload && this.nextFetchAllowedAt && Date.now() < this.nextFetchAllowedAt) return void this.logMsgIfDebug(() => console.debug("[FEATURE FLAGS] Skipping fetch, in backoff period"));
-    if (!this.loadingPromise) this.loadingPromise = this._loadFeatureFlags().catch((err) => this.logMsgIfDebug(() => console.debug(`[FEATURE FLAGS] Failed to load feature flags: ${err}`))).finally(() => {
-      this.loadingPromise = void 0;
-    });
-    return this.loadingPromise;
-  }
-  isLocalEvaluationReady() {
-    return (this.loadedSuccessfullyOnce ?? false) && (this.featureFlags?.length ?? 0) > 0;
-  }
-  getPollingInterval() {
-    if (!this.shouldBeginExponentialBackoff) return this.pollingInterval;
-    return Math.min(SIXTY_SECONDS, this.pollingInterval * 2 ** this.backOffCount);
-  }
-  beginBackoff() {
-    this.shouldBeginExponentialBackoff = true;
-    this.backOffCount += 1;
-    this.nextFetchAllowedAt = Date.now() + this.getPollingInterval();
-  }
-  clearBackoff() {
-    this.shouldBeginExponentialBackoff = false;
-    this.backOffCount = 0;
-    this.nextFetchAllowedAt = void 0;
-  }
-  async _loadFeatureFlags() {
-    if (this.poller) {
-      clearTimeout(this.poller);
-      this.poller = void 0;
-    }
-    this.poller = setTimeout(() => this.loadFeatureFlags(true), this.getPollingInterval());
-    try {
-      let shouldFetch = true;
-      if (this.cacheProvider) try {
-        shouldFetch = await this.cacheProvider.shouldFetchFlagDefinitions();
-      } catch (err) {
-        this.onError?.(new Error(`Error in shouldFetchFlagDefinitions: ${err}`));
-      }
-      if (!shouldFetch) {
-        const loaded = await this.loadFromCache("Loaded flags from cache (skipped fetch)");
-        if (loaded) return;
-        if (this.loadedSuccessfullyOnce) return;
-      }
-      const res = await this._requestFeatureFlagDefinitions();
-      if (!res) return;
-      switch (res.status) {
-        case 304:
-          this.logMsgIfDebug(() => console.debug("[FEATURE FLAGS] Flags not modified (304), using cached data"));
-          this.flagsEtag = res.headers?.get("ETag") ?? this.flagsEtag;
-          this.loadedSuccessfullyOnce = true;
-          this.clearBackoff();
-          return;
-        case 401:
-          this.beginBackoff();
-          throw new ClientError(`Your project key or personal API key is invalid. Setting next polling interval to ${this.getPollingInterval()}ms. More information: https://posthog.com/docs/api#rate-limiting`);
-        case 402:
-          console.warn("[FEATURE FLAGS] Feature flags quota limit exceeded - unsetting all local flags. Learn more about billing limits at https://posthog.com/docs/billing/limits-alerts");
-          this.featureFlags = [];
-          this.featureFlagsByKey = {};
-          this.groupTypeMapping = {};
-          this.cohorts = {};
-          return;
-        case 403:
-          this.beginBackoff();
-          throw new ClientError(`Your personal API key does not have permission to fetch feature flag definitions for local evaluation. Setting next polling interval to ${this.getPollingInterval()}ms. Are you sure you're using the correct personal and Project API key pair? More information: https://posthog.com/docs/api/overview`);
-        case 429:
-          this.beginBackoff();
-          throw new ClientError(`You are being rate limited. Setting next polling interval to ${this.getPollingInterval()}ms. More information: https://posthog.com/docs/api#rate-limiting`);
-        case 200: {
-          const responseJson = await res.json() ?? {};
-          if (!("flags" in responseJson)) return void this.onError?.(new Error(`Invalid response when getting feature flags: ${JSON.stringify(responseJson)}`));
-          this.flagsEtag = res.headers?.get("ETag") ?? void 0;
-          const flagData = {
-            flags: responseJson.flags ?? [],
-            groupTypeMapping: responseJson.group_type_mapping || {},
-            cohorts: responseJson.cohorts || {}
-          };
-          this.updateFlagState(flagData);
-          this.clearBackoff();
-          if (this.cacheProvider && shouldFetch) try {
-            await this.cacheProvider.onFlagDefinitionsReceived(flagData);
-          } catch (err) {
-            this.onError?.(new Error(`Failed to store in cache: ${err}`));
-          }
-          this.onLoad?.(this.featureFlags.length);
-          break;
-        }
-        default:
-          return;
-      }
-    } catch (err) {
-      if (err instanceof ClientError) this.onError?.(err);
-    }
-  }
-  getPersonalApiKeyRequestOptions(method = "GET", etag) {
-    const headers = {
-      ...this.customHeaders,
-      "Content-Type": "application/json",
-      Authorization: `Bearer ${this.personalApiKey}`
-    };
-    if (etag) headers["If-None-Match"] = etag;
-    return {
-      method,
-      headers
-    };
-  }
-  _requestFeatureFlagDefinitions() {
-    const url = `${this.host}/api/feature_flag/local_evaluation?token=${this.projectApiKey}&send_cohorts`;
-    const options = this.getPersonalApiKeyRequestOptions("GET", this.flagsEtag);
-    let abortTimeout = null;
-    if (this.timeout && "number" == typeof this.timeout) {
-      const controller = new AbortController();
-      abortTimeout = safeSetTimeout(() => {
-        controller.abort();
-      }, this.timeout);
-      options.signal = controller.signal;
-    }
-    try {
-      const fetch1 = this.fetch;
-      return fetch1(url, options);
-    } finally {
-      clearTimeout(abortTimeout);
-    }
-  }
-  async stopPoller(timeoutMs = 3e4) {
-    clearTimeout(this.poller);
-    if (this.cacheProvider) try {
-      const shutdownResult = this.cacheProvider.shutdown();
-      if (shutdownResult instanceof Promise) await Promise.race([
-        shutdownResult,
-        new Promise((_, reject) => setTimeout(() => reject(new Error(`Cache shutdown timeout after ${timeoutMs}ms`)), timeoutMs))
-      ]);
-    } catch (err) {
-      this.onError?.(new Error(`Error during cache shutdown: ${err}`));
-    }
-  }
-}
-async function _hash(key, distinctId, salt = "") {
-  const hashString = await hashSHA1(`${key}.${distinctId}${salt}`);
-  return parseInt(hashString.slice(0, 15), 16) / LONG_SCALE;
-}
-function matchProperty(property, propertyValues, warnFunction) {
-  const key = property.key;
-  const value = property.value;
-  const operator = property.operator || "exact";
-  if (key in propertyValues) {
-    if ("is_not_set" === operator) throw new InconclusiveMatchError("Operator is_not_set is not supported");
-  } else throw new InconclusiveMatchError(`Property ${key} not found in propertyValues`);
-  const overrideValue = propertyValues[key];
-  if (null == overrideValue && !NULL_VALUES_ALLOWED_OPERATORS.includes(operator)) {
-    if (warnFunction) warnFunction(`Property ${key} cannot have a value of null/undefined with the ${operator} operator`);
-    return false;
-  }
-  function computeExactMatch(value2, overrideValue2) {
-    if (Array.isArray(value2)) return value2.map((val) => String(val).toLowerCase()).includes(String(overrideValue2).toLowerCase());
-    return String(value2).toLowerCase() === String(overrideValue2).toLowerCase();
-  }
-  function compare(lhs, rhs, operator2) {
-    if ("gt" === operator2) return lhs > rhs;
-    if ("gte" === operator2) return lhs >= rhs;
-    if ("lt" === operator2) return lhs < rhs;
-    if ("lte" === operator2) return lhs <= rhs;
-    throw new Error(`Invalid operator: ${operator2}`);
-  }
-  switch (operator) {
-    case "exact":
-      return computeExactMatch(value, overrideValue);
-    case "is_not":
-      return !computeExactMatch(value, overrideValue);
-    case "is_set":
-      return key in propertyValues;
-    case "icontains":
-      return String(overrideValue).toLowerCase().includes(String(value).toLowerCase());
-    case "not_icontains":
-      return !String(overrideValue).toLowerCase().includes(String(value).toLowerCase());
-    case "regex":
-      return isValidRegex(String(value)) && null !== String(overrideValue).match(String(value));
-    case "not_regex":
-      return isValidRegex(String(value)) && null === String(overrideValue).match(String(value));
-    case "gt":
-    case "gte":
-    case "lt":
-    case "lte": {
-      let parsedValue = "number" == typeof value ? value : null;
-      if ("string" == typeof value) try {
-        parsedValue = parseFloat(value);
-      } catch (err) {
-      }
-      if (null == parsedValue || null == overrideValue) return compare(String(overrideValue), String(value), operator);
-      if ("string" == typeof overrideValue) return compare(overrideValue, String(value), operator);
-      return compare(overrideValue, parsedValue, operator);
-    }
-    case "is_date_after":
-    case "is_date_before": {
-      if ("boolean" == typeof value) throw new InconclusiveMatchError("Date operations cannot be performed on boolean values");
-      let parsedDate = relativeDateParseForFeatureFlagMatching(String(value));
-      if (null == parsedDate) parsedDate = convertToDateTime(value);
-      if (null == parsedDate) throw new InconclusiveMatchError(`Invalid date: ${value}`);
-      const overrideDate = convertToDateTime(overrideValue);
-      if ([
-        "is_date_before"
-      ].includes(operator)) return overrideDate < parsedDate;
-      return overrideDate > parsedDate;
-    }
-    default:
-      throw new InconclusiveMatchError(`Unknown operator: ${operator}`);
-  }
-}
-function checkCohortExists(cohortId, cohortProperties) {
-  if (!(cohortId in cohortProperties)) throw new RequiresServerEvaluation(`cohort ${cohortId} not found in local cohorts - likely a static cohort that requires server evaluation`);
-}
-function matchCohort(property, propertyValues, cohortProperties, debugMode = false) {
-  const cohortId = String(property.value);
-  checkCohortExists(cohortId, cohortProperties);
-  const propertyGroup = cohortProperties[cohortId];
-  return matchPropertyGroup(propertyGroup, propertyValues, cohortProperties, debugMode);
-}
-function matchPropertyGroup(propertyGroup, propertyValues, cohortProperties, debugMode = false) {
-  if (!propertyGroup) return true;
-  const propertyGroupType = propertyGroup.type;
-  const properties = propertyGroup.values;
-  if (!properties || 0 === properties.length) return true;
-  let errorMatchingLocally = false;
-  if ("values" in properties[0]) {
-    for (const prop of properties) try {
-      const matches = matchPropertyGroup(prop, propertyValues, cohortProperties, debugMode);
-      if ("AND" === propertyGroupType) {
-        if (!matches) return false;
-      } else if (matches) return true;
-    } catch (err) {
-      if (err instanceof RequiresServerEvaluation) throw err;
-      if (err instanceof InconclusiveMatchError) {
-        if (debugMode) console.debug(`Failed to compute property ${prop} locally: ${err}`);
-        errorMatchingLocally = true;
-      } else throw err;
-    }
-    if (errorMatchingLocally) throw new InconclusiveMatchError("Can't match cohort without a given cohort property value");
-    return "AND" === propertyGroupType;
-  }
-  for (const prop of properties) try {
-    let matches;
-    if ("cohort" === prop.type) matches = matchCohort(prop, propertyValues, cohortProperties, debugMode);
-    else if ("flag" === prop.type) {
-      if (debugMode) console.warn(`[FEATURE FLAGS] Flag dependency filters are not supported in local evaluation. Skipping condition with dependency on flag '${prop.key || "unknown"}'`);
-      continue;
-    } else matches = matchProperty(prop, propertyValues);
-    const negation = prop.negation || false;
-    if ("AND" === propertyGroupType) {
-      if (!matches && !negation) return false;
-      if (matches && negation) return false;
-    } else {
-      if (matches && !negation) return true;
-      if (!matches && negation) return true;
-    }
-  } catch (err) {
-    if (err instanceof RequiresServerEvaluation) throw err;
-    if (err instanceof InconclusiveMatchError) {
-      if (debugMode) console.debug(`Failed to compute property ${prop} locally: ${err}`);
-      errorMatchingLocally = true;
-    } else throw err;
-  }
-  if (errorMatchingLocally) throw new InconclusiveMatchError("can't match cohort without a given cohort property value");
-  return "AND" === propertyGroupType;
-}
-function isValidRegex(regex) {
-  try {
-    new RegExp(regex);
-    return true;
-  } catch (err) {
-    return false;
-  }
-}
-function convertToDateTime(value) {
-  if (value instanceof Date) return value;
-  if ("string" == typeof value || "number" == typeof value) {
-    const date = new Date(value);
-    if (!isNaN(date.valueOf())) return date;
-    throw new InconclusiveMatchError(`${value} is in an invalid date format`);
-  }
-  throw new InconclusiveMatchError(`The date provided ${value} must be a string, number, or date object`);
-}
-function relativeDateParseForFeatureFlagMatching(value) {
-  const regex = /^-?(?<number>[0-9]+)(?<interval>[a-z])$/;
-  const match = value.match(regex);
-  const parsedDt = new Date((/* @__PURE__ */ new Date()).toISOString());
-  if (!match) return null;
-  {
-    if (!match.groups) return null;
-    const number = parseInt(match.groups["number"]);
-    if (number >= 1e4) return null;
-    const interval = match.groups["interval"];
-    if ("h" == interval) parsedDt.setUTCHours(parsedDt.getUTCHours() - number);
-    else if ("d" == interval) parsedDt.setUTCDate(parsedDt.getUTCDate() - number);
-    else if ("w" == interval) parsedDt.setUTCDate(parsedDt.getUTCDate() - 7 * number);
-    else if ("m" == interval) parsedDt.setUTCMonth(parsedDt.getUTCMonth() - number);
-    else {
-      if ("y" != interval) return null;
-      parsedDt.setUTCFullYear(parsedDt.getUTCFullYear() - number);
-    }
-    return parsedDt;
-  }
-}
-class PostHogMemoryStorage {
-  getProperty(key) {
-    return this._memoryStorage[key];
-  }
-  setProperty(key, value) {
-    this._memoryStorage[key] = null !== value ? value : void 0;
-  }
-  constructor() {
-    this._memoryStorage = {};
-  }
-}
-const MINIMUM_POLLING_INTERVAL = 100;
-const THIRTY_SECONDS = 3e4;
-const MAX_CACHE_SIZE = 5e4;
-class PostHogBackendClient extends PostHogCoreStateless {
-  constructor(apiKey, options = {}) {
-    super(apiKey, options), this._memoryStorage = new PostHogMemoryStorage();
-    this.options = options;
-    this.context = this.initializeContext();
-    this.options.featureFlagsPollingInterval = "number" == typeof options.featureFlagsPollingInterval ? Math.max(options.featureFlagsPollingInterval, MINIMUM_POLLING_INTERVAL) : THIRTY_SECONDS;
-    if (options.personalApiKey) {
-      if (options.personalApiKey.includes("phc_")) throw new Error('Your Personal API key is invalid. These keys are prefixed with "phx_" and can be created in PostHog project settings.');
-      const shouldEnableLocalEvaluation = false !== options.enableLocalEvaluation;
-      if (shouldEnableLocalEvaluation) this.featureFlagsPoller = new FeatureFlagsPoller({
-        pollingInterval: this.options.featureFlagsPollingInterval,
-        personalApiKey: options.personalApiKey,
-        projectApiKey: apiKey,
-        timeout: options.requestTimeout ?? 1e4,
-        host: this.host,
-        fetch: options.fetch,
-        onError: (err) => {
-          this._events.emit("error", err);
-        },
-        onLoad: (count) => {
-          this._events.emit("localEvaluationFlagsLoaded", count);
-        },
-        customHeaders: this.getCustomHeaders(),
-        cacheProvider: options.flagDefinitionCacheProvider
-      });
-    }
-    this.errorTracking = new ErrorTracking(this, options, this._logger);
-    this.distinctIdHasSentFlagCalls = {};
-    this.maxCacheSize = options.maxCacheSize || MAX_CACHE_SIZE;
-  }
-  getPersistedProperty(key) {
-    return this._memoryStorage.getProperty(key);
-  }
-  setPersistedProperty(key, value) {
-    return this._memoryStorage.setProperty(key, value);
-  }
-  fetch(url, options) {
-    return this.options.fetch ? this.options.fetch(url, options) : fetch(url, options);
-  }
-  getLibraryVersion() {
-    return version;
-  }
-  getCustomUserAgent() {
-    return `${this.getLibraryId()}/${this.getLibraryVersion()}`;
-  }
-  enable() {
-    return super.optIn();
-  }
-  disable() {
-    return super.optOut();
-  }
-  debug(enabled = true) {
-    super.debug(enabled);
-    this.featureFlagsPoller?.debug(enabled);
-  }
-  capture(props) {
-    if ("string" == typeof props) this._logger.warn("Called capture() with a string as the first argument when an object was expected.");
-    this.addPendingPromise(this.prepareEventMessage(props).then(({ distinctId, event, properties, options }) => super.captureStateless(distinctId, event, properties, {
-      timestamp: options.timestamp,
-      disableGeoip: options.disableGeoip,
-      uuid: options.uuid
-    })).catch((err) => {
-      if (err) console.error(err);
-    }));
-  }
-  async captureImmediate(props) {
-    if ("string" == typeof props) this._logger.warn("Called captureImmediate() with a string as the first argument when an object was expected.");
-    return this.addPendingPromise(this.prepareEventMessage(props).then(({ distinctId, event, properties, options }) => super.captureStatelessImmediate(distinctId, event, properties, {
-      timestamp: options.timestamp,
-      disableGeoip: options.disableGeoip,
-      uuid: options.uuid
-    })).catch((err) => {
-      if (err) console.error(err);
-    }));
-  }
-  identify({ distinctId, properties = {}, disableGeoip }) {
-    const { $set, $set_once, $anon_distinct_id, ...rest } = properties;
-    const setProps = $set || rest;
-    const setOnceProps = $set_once || {};
-    const eventProperties = {
-      $set: setProps,
-      $set_once: setOnceProps,
-      $anon_distinct_id: $anon_distinct_id ?? void 0
-    };
-    super.identifyStateless(distinctId, eventProperties, {
-      disableGeoip
-    });
-  }
-  async identifyImmediate({ distinctId, properties = {}, disableGeoip }) {
-    const { $set, $set_once, $anon_distinct_id, ...rest } = properties;
-    const setProps = $set || rest;
-    const setOnceProps = $set_once || {};
-    const eventProperties = {
-      $set: setProps,
-      $set_once: setOnceProps,
-      $anon_distinct_id: $anon_distinct_id ?? void 0
-    };
-    super.identifyStatelessImmediate(distinctId, eventProperties, {
-      disableGeoip
-    });
-  }
-  alias(data) {
-    super.aliasStateless(data.alias, data.distinctId, void 0, {
-      disableGeoip: data.disableGeoip
-    });
-  }
-  async aliasImmediate(data) {
-    await super.aliasStatelessImmediate(data.alias, data.distinctId, void 0, {
-      disableGeoip: data.disableGeoip
-    });
-  }
-  isLocalEvaluationReady() {
-    return this.featureFlagsPoller?.isLocalEvaluationReady() ?? false;
-  }
-  async waitForLocalEvaluationReady(timeoutMs = THIRTY_SECONDS) {
-    if (this.isLocalEvaluationReady()) return true;
-    if (void 0 === this.featureFlagsPoller) return false;
-    return new Promise((resolve) => {
-      const timeout = setTimeout(() => {
-        cleanup();
-        resolve(false);
-      }, timeoutMs);
-      const cleanup = this._events.on("localEvaluationFlagsLoaded", (count) => {
-        clearTimeout(timeout);
-        cleanup();
-        resolve(count > 0);
-      });
-    });
-  }
-  async getFeatureFlag(key, distinctId, options) {
-    if (void 0 !== this._flagOverrides && key in this._flagOverrides) return this._flagOverrides[key];
-    const { groups, disableGeoip } = options || {};
-    let { onlyEvaluateLocally, sendFeatureFlagEvents, personProperties, groupProperties } = options || {};
-    const adjustedProperties = this.addLocalPersonAndGroupProperties(distinctId, groups, personProperties, groupProperties);
-    personProperties = adjustedProperties.allPersonProperties;
-    groupProperties = adjustedProperties.allGroupProperties;
-    if (void 0 == onlyEvaluateLocally) onlyEvaluateLocally = false;
-    if (void 0 == sendFeatureFlagEvents) sendFeatureFlagEvents = this.options.sendFeatureFlagEvent ?? true;
-    let response = await this.featureFlagsPoller?.getFeatureFlag(key, distinctId, groups, personProperties, groupProperties);
-    const flagWasLocallyEvaluated = void 0 !== response;
-    let requestId;
-    let evaluatedAt;
-    let flagDetail;
-    let featureFlagError;
-    if (!flagWasLocallyEvaluated && !onlyEvaluateLocally) {
-      const flagsResponse = await super.getFeatureFlagDetailsStateless(distinctId, groups, personProperties, groupProperties, disableGeoip, [
-        key
-      ]);
-      if (void 0 === flagsResponse) featureFlagError = FeatureFlagError.UNKNOWN_ERROR;
-      else {
-        requestId = flagsResponse.requestId;
-        evaluatedAt = flagsResponse.evaluatedAt;
-        const errors = [];
-        if (flagsResponse.errorsWhileComputingFlags) errors.push(FeatureFlagError.ERRORS_WHILE_COMPUTING);
-        if (flagsResponse.quotaLimited?.includes("feature_flags")) errors.push(FeatureFlagError.QUOTA_LIMITED);
-        flagDetail = flagsResponse.flags[key];
-        if (void 0 === flagDetail) errors.push(FeatureFlagError.FLAG_MISSING);
-        if (errors.length > 0) featureFlagError = errors.join(",");
-        response = getFeatureFlagValue(flagDetail);
-      }
-    }
-    const featureFlagReportedKey = `${key}_${response}`;
-    if (sendFeatureFlagEvents && (!(distinctId in this.distinctIdHasSentFlagCalls) || !this.distinctIdHasSentFlagCalls[distinctId].includes(featureFlagReportedKey))) {
-      if (Object.keys(this.distinctIdHasSentFlagCalls).length >= this.maxCacheSize) this.distinctIdHasSentFlagCalls = {};
-      if (Array.isArray(this.distinctIdHasSentFlagCalls[distinctId])) this.distinctIdHasSentFlagCalls[distinctId].push(featureFlagReportedKey);
-      else this.distinctIdHasSentFlagCalls[distinctId] = [
-        featureFlagReportedKey
-      ];
-      const properties = {
-        $feature_flag: key,
-        $feature_flag_response: response,
-        $feature_flag_id: flagDetail?.metadata?.id,
-        $feature_flag_version: flagDetail?.metadata?.version,
-        $feature_flag_reason: flagDetail?.reason?.description ?? flagDetail?.reason?.code,
-        locally_evaluated: flagWasLocallyEvaluated,
-        [`$feature/${key}`]: response,
-        $feature_flag_request_id: requestId,
-        $feature_flag_evaluated_at: evaluatedAt
-      };
-      if (featureFlagError) properties.$feature_flag_error = featureFlagError;
-      this.capture({
-        distinctId,
-        event: "$feature_flag_called",
-        properties,
-        groups,
-        disableGeoip
-      });
-    }
-    return response;
-  }
-  async getFeatureFlagPayload(key, distinctId, matchValue, options) {
-    if (void 0 !== this._payloadOverrides && key in this._payloadOverrides) return this._payloadOverrides[key];
-    const { groups, disableGeoip } = options || {};
-    let { onlyEvaluateLocally, personProperties, groupProperties } = options || {};
-    const adjustedProperties = this.addLocalPersonAndGroupProperties(distinctId, groups, personProperties, groupProperties);
-    personProperties = adjustedProperties.allPersonProperties;
-    groupProperties = adjustedProperties.allGroupProperties;
-    let response;
-    const localEvaluationEnabled = void 0 !== this.featureFlagsPoller;
-    if (localEvaluationEnabled) {
-      await this.featureFlagsPoller?.loadFeatureFlags();
-      const flag = this.featureFlagsPoller?.featureFlagsByKey[key];
-      if (flag) try {
-        const result = await this.featureFlagsPoller?.computeFlagAndPayloadLocally(flag, distinctId, groups, personProperties, groupProperties, matchValue);
-        if (result) {
-          matchValue = result.value;
-          response = result.payload;
-        }
-      } catch (e) {
-        if (e instanceof RequiresServerEvaluation || e instanceof InconclusiveMatchError) this._logger?.info(`${e.name} when computing flag locally: ${flag.key}: ${e.message}`);
-        else throw e;
-      }
-    }
-    if (void 0 == onlyEvaluateLocally) onlyEvaluateLocally = false;
-    const payloadWasLocallyEvaluated = void 0 !== response;
-    if (!payloadWasLocallyEvaluated && !onlyEvaluateLocally) response = await super.getFeatureFlagPayloadStateless(key, distinctId, groups, personProperties, groupProperties, disableGeoip);
-    return response;
-  }
-  async getRemoteConfigPayload(flagKey) {
-    if (!this.options.personalApiKey) throw new Error("Personal API key is required for remote config payload decryption");
-    const response = await this._requestRemoteConfigPayload(flagKey);
-    if (!response) return;
-    const parsed = await response.json();
-    if ("string" == typeof parsed) try {
-      return JSON.parse(parsed);
-    } catch (e) {
-    }
-    return parsed;
-  }
-  async isFeatureEnabled(key, distinctId, options) {
-    const feat = await this.getFeatureFlag(key, distinctId, options);
-    if (void 0 === feat) return;
-    return !!feat || false;
-  }
-  async getAllFlags(distinctId, options) {
-    const response = await this.getAllFlagsAndPayloads(distinctId, options);
-    return response.featureFlags || {};
-  }
-  async getAllFlagsAndPayloads(distinctId, options) {
-    const { groups, disableGeoip, flagKeys } = options || {};
-    let { onlyEvaluateLocally, personProperties, groupProperties } = options || {};
-    const adjustedProperties = this.addLocalPersonAndGroupProperties(distinctId, groups, personProperties, groupProperties);
-    personProperties = adjustedProperties.allPersonProperties;
-    groupProperties = adjustedProperties.allGroupProperties;
-    if (void 0 == onlyEvaluateLocally) onlyEvaluateLocally = false;
-    const localEvaluationResult = await this.featureFlagsPoller?.getAllFlagsAndPayloads(distinctId, groups, personProperties, groupProperties, flagKeys);
-    let featureFlags = {};
-    let featureFlagPayloads = {};
-    let fallbackToFlags = true;
-    if (localEvaluationResult) {
-      featureFlags = localEvaluationResult.response;
-      featureFlagPayloads = localEvaluationResult.payloads;
-      fallbackToFlags = localEvaluationResult.fallbackToFlags;
-    }
-    if (fallbackToFlags && !onlyEvaluateLocally) {
-      const remoteEvaluationResult = await super.getFeatureFlagsAndPayloadsStateless(distinctId, groups, personProperties, groupProperties, disableGeoip, flagKeys);
-      featureFlags = {
-        ...featureFlags,
-        ...remoteEvaluationResult.flags || {}
-      };
-      featureFlagPayloads = {
-        ...featureFlagPayloads,
-        ...remoteEvaluationResult.payloads || {}
-      };
-    }
-    if (void 0 !== this._flagOverrides) featureFlags = {
-      ...featureFlags,
-      ...this._flagOverrides
-    };
-    if (void 0 !== this._payloadOverrides) featureFlagPayloads = {
-      ...featureFlagPayloads,
-      ...this._payloadOverrides
-    };
-    return {
-      featureFlags,
-      featureFlagPayloads
-    };
-  }
-  groupIdentify({ groupType, groupKey, properties, distinctId, disableGeoip }) {
-    super.groupIdentifyStateless(groupType, groupKey, properties, {
-      disableGeoip
-    }, distinctId);
-  }
-  async reloadFeatureFlags() {
-    await this.featureFlagsPoller?.loadFeatureFlags(true);
-  }
-  overrideFeatureFlags(overrides) {
-    const flagArrayToRecord = (flags) => Object.fromEntries(flags.map((f) => [
-      f,
-      true
-    ]));
-    if (false === overrides) {
-      this._flagOverrides = void 0;
-      this._payloadOverrides = void 0;
-      return;
-    }
-    if (Array.isArray(overrides)) {
-      this._flagOverrides = flagArrayToRecord(overrides);
-      return;
-    }
-    if (this._isFeatureFlagOverrideOptions(overrides)) {
-      if ("flags" in overrides) {
-        if (false === overrides.flags) this._flagOverrides = void 0;
-        else if (Array.isArray(overrides.flags)) this._flagOverrides = flagArrayToRecord(overrides.flags);
-        else if (void 0 !== overrides.flags) this._flagOverrides = {
-          ...overrides.flags
-        };
-      }
-      if ("payloads" in overrides) {
-        if (false === overrides.payloads) this._payloadOverrides = void 0;
-        else if (void 0 !== overrides.payloads) this._payloadOverrides = {
-          ...overrides.payloads
-        };
-      }
-      return;
-    }
-    this._flagOverrides = {
-      ...overrides
-    };
-  }
-  _isFeatureFlagOverrideOptions(overrides) {
-    if ("object" != typeof overrides || null === overrides || Array.isArray(overrides)) return false;
-    const obj = overrides;
-    if ("flags" in obj) {
-      const flagsValue = obj["flags"];
-      if (false === flagsValue || Array.isArray(flagsValue) || "object" == typeof flagsValue && null !== flagsValue) return true;
-    }
-    if ("payloads" in obj) {
-      const payloadsValue = obj["payloads"];
-      if (false === payloadsValue || "object" == typeof payloadsValue && null !== payloadsValue) return true;
-    }
-    return false;
-  }
-  withContext(data, fn, options) {
-    if (!this.context) return fn();
-    return this.context.run(data, fn, options);
-  }
-  getContext() {
-    return this.context?.get();
-  }
-  async _shutdown(shutdownTimeoutMs) {
-    this.featureFlagsPoller?.stopPoller(shutdownTimeoutMs);
-    this.errorTracking.shutdown();
-    return super._shutdown(shutdownTimeoutMs);
-  }
-  async _requestRemoteConfigPayload(flagKey) {
-    if (!this.options.personalApiKey) return;
-    const url = `${this.host}/api/projects/@current/feature_flags/${flagKey}/remote_config?token=${encodeURIComponent(this.apiKey)}`;
-    const options = {
-      method: "GET",
-      headers: {
-        ...this.getCustomHeaders(),
-        "Content-Type": "application/json",
-        Authorization: `Bearer ${this.options.personalApiKey}`
-      }
-    };
-    let abortTimeout = null;
-    if (this.options.requestTimeout && "number" == typeof this.options.requestTimeout) {
-      const controller = new AbortController();
-      abortTimeout = safeSetTimeout(() => {
-        controller.abort();
-      }, this.options.requestTimeout);
-      options.signal = controller.signal;
-    }
-    try {
-      return await this.fetch(url, options);
-    } catch (error) {
-      this._events.emit("error", error);
-      return;
-    } finally {
-      if (abortTimeout) clearTimeout(abortTimeout);
-    }
-  }
-  extractPropertiesFromEvent(eventProperties, groups) {
-    if (!eventProperties) return {
-      personProperties: {},
-      groupProperties: {}
-    };
-    const personProperties = {};
-    const groupProperties = {};
-    for (const [key, value] of Object.entries(eventProperties)) if (isPlainObject(value) && groups && key in groups) {
-      const groupProps = {};
-      for (const [groupKey, groupValue] of Object.entries(value)) groupProps[String(groupKey)] = String(groupValue);
-      groupProperties[String(key)] = groupProps;
-    } else personProperties[String(key)] = String(value);
-    return {
-      personProperties,
-      groupProperties
-    };
-  }
-  async getFeatureFlagsForEvent(distinctId, groups, disableGeoip, sendFeatureFlagsOptions) {
-    const finalPersonProperties = sendFeatureFlagsOptions?.personProperties || {};
-    const finalGroupProperties = sendFeatureFlagsOptions?.groupProperties || {};
-    const flagKeys = sendFeatureFlagsOptions?.flagKeys;
-    const onlyEvaluateLocally = sendFeatureFlagsOptions?.onlyEvaluateLocally ?? false;
-    if (onlyEvaluateLocally) if (!((this.featureFlagsPoller?.featureFlags?.length || 0) > 0)) return {};
-    else {
-      const groupsWithStringValues = {};
-      for (const [key, value] of Object.entries(groups || {})) groupsWithStringValues[key] = String(value);
-      return await this.getAllFlags(distinctId, {
-        groups: groupsWithStringValues,
-        personProperties: finalPersonProperties,
-        groupProperties: finalGroupProperties,
-        disableGeoip,
-        onlyEvaluateLocally: true,
-        flagKeys
-      });
-    }
-    if ((this.featureFlagsPoller?.featureFlags?.length || 0) > 0) {
-      const groupsWithStringValues = {};
-      for (const [key, value] of Object.entries(groups || {})) groupsWithStringValues[key] = String(value);
-      return await this.getAllFlags(distinctId, {
-        groups: groupsWithStringValues,
-        personProperties: finalPersonProperties,
-        groupProperties: finalGroupProperties,
-        disableGeoip,
-        onlyEvaluateLocally: true,
-        flagKeys
-      });
-    }
-    return (await super.getFeatureFlagsStateless(distinctId, groups, finalPersonProperties, finalGroupProperties, disableGeoip)).flags;
-  }
-  addLocalPersonAndGroupProperties(distinctId, groups, personProperties, groupProperties) {
-    const allPersonProperties = {
-      distinct_id: distinctId,
-      ...personProperties || {}
-    };
-    const allGroupProperties = {};
-    if (groups) for (const groupName of Object.keys(groups)) allGroupProperties[groupName] = {
-      $group_key: groups[groupName],
-      ...groupProperties?.[groupName] || {}
-    };
-    return {
-      allPersonProperties,
-      allGroupProperties
-    };
-  }
-  captureException(error, distinctId, additionalProperties, uuid) {
-    if (!ErrorTracking.isPreviouslyCapturedError(error)) {
-      const syntheticException = new Error("PostHog syntheticException");
-      this.addPendingPromise(ErrorTracking.buildEventMessage(error, {
-        syntheticException
-      }, distinctId, additionalProperties).then((msg) => this.capture({
-        ...msg,
-        uuid
-      })));
-    }
-  }
-  async captureExceptionImmediate(error, distinctId, additionalProperties) {
-    if (!ErrorTracking.isPreviouslyCapturedError(error)) {
-      const syntheticException = new Error("PostHog syntheticException");
-      this.addPendingPromise(ErrorTracking.buildEventMessage(error, {
-        syntheticException
-      }, distinctId, additionalProperties).then((msg) => this.captureImmediate(msg)));
-    }
-  }
-  async prepareEventMessage(props) {
-    const { distinctId, event, properties, groups, sendFeatureFlags, timestamp, disableGeoip, uuid } = props;
-    const contextData = this.context?.get();
-    let mergedDistinctId = distinctId || contextData?.distinctId;
-    const mergedProperties = {
-      ...contextData?.properties || {},
-      ...properties || {}
-    };
-    if (!mergedDistinctId) {
-      mergedDistinctId = uuidv7();
-      mergedProperties.$process_person_profile = false;
-    }
-    if (contextData?.sessionId && !mergedProperties.$session_id) mergedProperties.$session_id = contextData.sessionId;
-    const eventMessage = this._runBeforeSend({
-      distinctId: mergedDistinctId,
-      event,
-      properties: mergedProperties,
-      groups,
-      sendFeatureFlags,
-      timestamp,
-      disableGeoip,
-      uuid
-    });
-    if (!eventMessage) return Promise.reject(null);
-    const eventProperties = await Promise.resolve().then(async () => {
-      if (sendFeatureFlags) {
-        const sendFeatureFlagsOptions = "object" == typeof sendFeatureFlags ? sendFeatureFlags : void 0;
-        return await this.getFeatureFlagsForEvent(eventMessage.distinctId, groups, disableGeoip, sendFeatureFlagsOptions);
-      }
-      eventMessage.event;
-      return {};
-    }).then((flags) => {
-      const additionalProperties = {};
-      if (flags) for (const [feature, variant] of Object.entries(flags)) additionalProperties[`$feature/${feature}`] = variant;
-      const activeFlags = Object.keys(flags || {}).filter((flag) => flags?.[flag] !== false).sort();
-      if (activeFlags.length > 0) additionalProperties["$active_feature_flags"] = activeFlags;
-      return additionalProperties;
-    }).catch(() => ({})).then((additionalProperties) => {
-      const props2 = {
-        ...additionalProperties,
-        ...eventMessage.properties || {},
-        $groups: eventMessage.groups || groups
-      };
-      return props2;
-    });
-    if ("$pageview" === eventMessage.event && this.options.__preview_capture_bot_pageviews && "string" == typeof eventProperties.$raw_user_agent) {
-      if (isBlockedUA(eventProperties.$raw_user_agent, this.options.custom_blocked_useragents || [])) {
-        eventMessage.event = "$bot_pageview";
-        eventProperties.$browser_type = "bot";
-      }
-    }
-    return {
-      distinctId: eventMessage.distinctId,
-      event: eventMessage.event,
-      properties: eventProperties,
-      options: {
-        timestamp: eventMessage.timestamp,
-        disableGeoip: eventMessage.disableGeoip,
-        uuid: eventMessage.uuid
-      }
-    };
-  }
-  _runBeforeSend(eventMessage) {
-    const beforeSend = this.options.before_send;
-    if (!beforeSend) return eventMessage;
-    const fns = Array.isArray(beforeSend) ? beforeSend : [
-      beforeSend
-    ];
-    let result = eventMessage;
-    for (const fn of fns) {
-      result = fn(result);
-      if (!result) {
-        this._logger.info(`Event '${eventMessage.event}' was rejected in beforeSend function`);
-        return null;
-      }
-      if (!result.properties || 0 === Object.keys(result.properties).length) {
-        const message = `Event '${result.event}' has no properties after beforeSend function, this is likely an error.`;
-        this._logger.warn(message);
-      }
-    }
-    return result;
-  }
-}
-class PostHogContext {
-  constructor() {
-    this.storage = new AsyncLocalStorage();
-  }
-  get() {
-    return this.storage.getStore();
-  }
-  run(context, fn, options) {
-    const fresh = options?.fresh === true;
-    if (fresh) return this.storage.run(context, fn);
-    {
-      const currentContext = this.get() || {};
-      const mergedContext = {
-        distinctId: context.distinctId ?? currentContext.distinctId,
-        sessionId: context.sessionId ?? currentContext.sessionId,
-        properties: {
-          ...currentContext.properties || {},
-          ...context.properties || {}
-        }
-      };
-      return this.storage.run(mergedContext, fn);
-    }
-  }
-}
-function setupExpressErrorHandler(_posthog, app) {
-  app.use(posthogErrorHandler(_posthog));
-}
-function posthogErrorHandler(posthog) {
-  return (error, req, res, next) => {
-    if (ErrorTracking.isPreviouslyCapturedError(error)) return void next(error);
-    const sessionId = req.headers["x-posthog-session-id"];
-    const distinctId = req.headers["x-posthog-distinct-id"];
-    const syntheticException = new Error("Synthetic exception");
-    const hint = {
-      mechanism: {
-        type: "middleware",
-        handled: false
-      },
-      syntheticException
-    };
-    posthog.addPendingPromise(ErrorTracking.buildEventMessage(error, hint, distinctId, {
-      $session_id: sessionId,
-      $current_url: req.url,
-      $request_method: req.method,
-      $request_path: req.path,
-      $user_agent: req.headers["user-agent"],
-      $response_status_code: res.statusCode,
-      $ip: req.headers["x-forwarded-for"] || req?.socket?.remoteAddress
-    }).then((msg) => {
-      posthog.capture(msg);
-    }));
-    next(error);
-  };
-}
-ErrorTracking.errorPropertiesBuilder = new ErrorPropertiesBuilder([
-  new EventCoercer(),
-  new ErrorCoercer(),
-  new ObjectCoercer(),
-  new StringCoercer(),
-  new PrimitiveCoercer()
-], createStackParser("node:javascript", nodeStackLineParser), [
-  createModulerModifier(),
-  addSourceContext
-]);
-class PostHog extends PostHogBackendClient {
-  getLibraryId() {
-    return "posthog-node";
-  }
-  initializeContext() {
-    return new PostHogContext();
-  }
-}
-let client;
-let shutdownHookBound = false;
-const resolveApiKey = (env2) => env2.POSTHOG_API_KEY || env2.POSTHOG_KEY || env2.POSTHOG_SERVER_KEY;
-const resolveHost = (env2) => env2.POSTHOG_HOST || env2.RB_POSTHOG_HOST || "https://eu.i.posthog.com";
-const getPosthogClient = (env2) => {
-  if (client !== void 0) return client;
-  const apiKey = resolveApiKey(env2);
-  if (!apiKey) {
-    client = null;
-    return client;
-  }
-  client = new PostHog(apiKey, {
-    host: resolveHost(env2),
-    enableExceptionAutocapture: true,
-    flushAt: 1,
-    flushInterval: 1e3
-  });
-  return client;
-};
-const bindExpressErrorHandler = (app, posthog) => {
-  if (!posthog) return;
-  setupExpressErrorHandler(posthog, app);
-};
-const captureServerException = (error, posthog, properties) => {
-  const clientToUse = posthog ?? client ?? null;
-  if (!clientToUse || typeof clientToUse.captureException !== "function") return;
-  clientToUse.captureException(error, "server", properties);
-};
-const shutdown = async () => {
-  if (!client) return;
-  try {
-    await client.shutdown();
-  } catch (err) {
-    console.error("posthog shutdown error", err);
-  }
-};
-const ensurePosthogShutdown = () => {
-  if (shutdownHookBound || !client) return;
-  shutdownHookBound = true;
-  const stop = () => {
-    void shutdown();
-  };
-  process.on("SIGTERM", stop);
-  process.on("SIGINT", stop);
-  process.on("beforeExit", shutdown);
-};
-const getDerivedKey = (masterKey, info, length = 32, salt = "") => {
-  assert$1(masterKey?.length >= 32, "MASTER_KEY must be 32 chars or longer.");
-  return Buffer.from(hkdfSync(
-    "sha256",
-    masterKey,
-    Buffer.from(salt),
-    Buffer.from(info),
-    length
-  )).toString("hex");
-};
-const POSTHOG_INGEST_TARGET = "https://eu.i.posthog.com";
-const getStatusCode = (errorCode) => {
-  if (typeof errorCode === "string" && /HPE_INVALID/.test(errorCode)) {
-    return 502;
-  }
-  switch (errorCode) {
-    case "ECONNRESET":
-    case "ENOTFOUND":
-    case "ECONNREFUSED":
-    case "ETIMEDOUT":
-      return 504;
-    default:
-      return 500;
-  }
-};
-const proxy = httpProxy.createProxyServer({
-  changeOrigin: true
-});
-proxy.on("error", (err, req, res) => {
-  console.error(`Proxy error: ${err?.message ?? String(err)}`);
-  if (!res || typeof res.writeHead !== "function") return;
-  if (res.headersSent) return;
-  const statusCode = getStatusCode(err?.code);
-  res.writeHead(statusCode);
-  const host = req?.headers?.host ?? "";
-  const url = req?.url ?? "";
-  res.end(`Error occurred while trying to proxy: ${host}${url}`);
-});
-const metricsIngestProxyMiddleware = (app) => {
-  app.use("/ingest", (req, res) => {
-    if (!req.url) {
-      req.url = "/";
-    }
-    proxy.web(req, res, { target: POSTHOG_INGEST_TARGET });
-  });
-};
-const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
-let hasWarnedNoReplicationEnabled = false;
-const checkInitReplicaSet = async (serverEnv) => {
-  const port = serverEnv.DB_PORT?.trim();
-  if (!port) return;
-  const host = (serverEnv.DB_HOST ?? "localhost").trim();
-  const replSetName = "rs0";
-  const memberHost = `${host}:${port}`;
-  const maxAttempts = 10;
-  const serverSelectionTimeoutMs = 2e3;
-  const uri = `mongodb://${host}:${port}/?directConnection=true`;
-  const waitForReplicaSetReady = async (admin) => {
-    const maxWaitAttempts = 10;
-    for (let attempt = 1; attempt <= maxWaitAttempts; attempt++) {
-      try {
-        const status = await admin.command({ replSetGetStatus: 1 });
-        const state = Number(status?.myState ?? 0);
-        if (status?.ok && (state === 1 || state === 2)) return;
-      } catch {
-      }
-      await sleep(250 * attempt);
-    }
-  };
-  for (let attempt = 1; attempt <= maxAttempts; attempt++) {
-    let client2 = null;
-    try {
-      client2 = new MongoClient(uri, {
-        family: 4,
-        serverSelectionTimeoutMS: serverSelectionTimeoutMs,
-        connectTimeoutMS: serverSelectionTimeoutMs
-      });
-      await client2.connect();
-      const admin = client2.db("admin").admin();
-      await admin.command({ ping: 1 });
-      try {
-        await admin.command({ replSetGetStatus: 1 });
-        return;
-      } catch (error) {
-        const codeName = error?.codeName;
-        if (codeName === "NotYetInitialized") {
-          try {
-            const res = await admin.command({
-              replSetInitiate: {
-                _id: replSetName,
-                members: [{ _id: 0, host: memberHost }]
-              }
-            });
-            if (res?.ok) {
-              console.warn(`[rb/server] MongoDB replica set '${replSetName}' initiated (${memberHost}).`);
-            } else {
-              console.warn(`[rb/server] MongoDB replica set initiation returned ok=${String(res?.ok)}.`);
-            }
-          } catch (initError) {
-            const initCodeName = initError?.codeName;
-            if (initCodeName !== "AlreadyInitialized") {
-              const message2 = initError instanceof Error ? initError.message : String(initError);
-              console.warn(`[rb/server] MongoDB replica set initiation failed: ${message2}`);
-              if (initCodeName === "InvalidReplicaSetConfig") {
-                console.warn(
-                  `[rb/server] Hint: the replica set member host must match the mongod address/port. If MongoDB runs in Docker with port mapping, ensure the container listens on ${port} (e.g. mongod --port ${port}) instead of the default 27017.`
-                );
-              }
-            }
-          }
-          await waitForReplicaSetReady(admin);
-          return;
-        }
-        if (codeName === "NoReplicationEnabled") {
-          if (!hasWarnedNoReplicationEnabled) {
-            hasWarnedNoReplicationEnabled = true;
-            console.warn(
-              `[rb/server] MongoDB is not started with --replSet ${replSetName} (replication disabled). Change streams require a replica set; start mongod with --replSet.`
-            );
-          }
-          return;
-        }
-        const message = error instanceof Error ? error.message : String(error);
-        console.warn(`[rb/server] MongoDB replica set check failed: ${message}`);
-        return;
-      }
-    } catch (error) {
-      if (attempt === maxAttempts) {
-        const message = error instanceof Error ? error.message : String(error);
-        console.warn(`[rb/server] MongoDB replica set auto-init skipped (unable to connect to ${host}:${port}): ${message}`);
-        return;
-      }
-      await sleep(250 * attempt);
-    } finally {
-      try {
-        await client2?.close();
-      } catch {
-      }
-    }
-  }
-};
-const VITE_FS_PREFIX = "/@fs/";
-let activeRun = null;
-const post = async (session2, method, params) => {
-  return await new Promise((resolve, reject) => {
-    session2.post(method, params, (error, result) => {
-      if (error) {
-        reject(error);
-        return;
-      }
-      resolve(result);
-    });
-  });
-};
-const describeError = (error) => {
-  return error instanceof Error ? error.message : String(error);
-};
-const findWorkspaceRoot = (projectRoot) => {
-  let dir = path.resolve(projectRoot);
-  while (true) {
-    const pkgPath = path.join(dir, "package.json");
-    try {
-      if (fs.existsSync(pkgPath)) {
-        const parsed = JSON.parse(fs.readFileSync(pkgPath, "utf8"));
-        if (parsed && typeof parsed === "object" && parsed.workspaces) {
-          return dir;
-        }
-      }
-    } catch {
-    }
-    const parent = path.dirname(dir);
-    if (parent === dir) {
-      return path.resolve(projectRoot);
-    }
-    dir = parent;
-  }
-};
-const stripQuery = (url) => {
-  const queryIndex = url.indexOf("?");
-  const hashIndex = url.indexOf("#");
-  const endIndex = Math.min(
-    queryIndex === -1 ? Number.POSITIVE_INFINITY : queryIndex,
-    hashIndex === -1 ? Number.POSITIVE_INFINITY : hashIndex
-  );
-  if (!Number.isFinite(endIndex)) {
-    return url;
-  }
-  return url.slice(0, endIndex);
-};
-const resolveAbsoluteFromUrl = (rawUrl, roots) => {
-  const cleaned = stripQuery(rawUrl);
-  try {
-    if (cleaned.startsWith("file://")) {
-      return path.normalize(fileURLToPath(cleaned));
-    }
-  } catch {
-  }
-  let pathname = cleaned;
-  try {
-    const parsed = new URL(cleaned);
-    pathname = parsed.pathname;
-  } catch {
-  }
-  const decoded = decodeURIComponent(pathname);
-  if (decoded.startsWith(VITE_FS_PREFIX)) {
-    return path.normalize(decoded.slice(VITE_FS_PREFIX.length));
-  }
-  if (!path.isAbsolute(decoded)) {
-    return null;
-  }
-  if (fs.existsSync(decoded)) {
-    return path.normalize(decoded);
-  }
-  const projectRoot = path.resolve(roots.projectRoot);
-  const workspaceRoot = path.resolve(roots.workspaceRoot);
-  if (decoded.startsWith(projectRoot + path.sep) || decoded.startsWith(workspaceRoot + path.sep)) {
-    return path.normalize(decoded);
-  }
-  return path.resolve(projectRoot, `.${decoded}`);
-};
-const normalizeScriptUrl = async (rawUrl, roots) => {
-  if (!rawUrl || rawUrl.startsWith("node:")) {
-    return null;
-  }
-  const absolute = resolveAbsoluteFromUrl(rawUrl, roots);
-  if (!absolute) {
-    return null;
-  }
-  let realPath = absolute;
-  try {
-    realPath = await fsPromises.realpath(absolute);
-  } catch {
-  }
-  const normalized = path.normalize(realPath);
-  if (normalized.includes(`${path.sep}node_modules${path.sep}`)) {
-    return null;
-  }
-  const workspaceRoot = path.resolve(roots.workspaceRoot);
-  const projectRoot = path.resolve(roots.projectRoot);
-  if (normalized.startsWith(workspaceRoot + path.sep) || normalized === workspaceRoot) {
-    return {
-      absolutePath: normalized,
-      relativePath: path.relative(workspaceRoot, normalized)
-    };
-  }
-  if (normalized.startsWith(projectRoot + path.sep) || normalized === projectRoot) {
-    return {
-      absolutePath: normalized,
-      relativePath: path.relative(projectRoot, normalized)
-    };
-  }
-  return null;
-};
-const fetchScriptSource = async (session2, scriptId) => {
-  try {
-    const response = await post(session2, "Debugger.getScriptSource", { scriptId });
-    return typeof response?.scriptSource === "string" ? response.scriptSource : "";
-  } catch {
-    return "";
-  }
-};
-const resolveScriptSource = async (session2, cache, scriptId) => {
-  const cached = cache.get(scriptId);
-  if (cached) {
-    return await cached;
-  }
-  const promise = fetchScriptSource(session2, scriptId);
-  cache.set(scriptId, promise);
-  return await promise;
-};
-const shutdownSession = async (session2) => {
-  await Promise.allSettled([
-    post(session2, "Profiler.stopPreciseCoverage").catch(() => void 0),
-    post(session2, "Profiler.disable").catch(() => void 0),
-    post(session2, "Debugger.disable").catch(() => void 0)
-  ]);
-  try {
-    session2.disconnect();
-  } catch {
-  }
-};
-const toPosixPath = (input) => input.split(path.sep).join("/");
-const isSubpath = (candidate, root) => {
-  const relative = path.relative(root, candidate);
-  return relative === "" || !relative.startsWith("..") && !path.isAbsolute(relative);
-};
-const classifyServerTarget = (absolutePath, projectRoot) => {
-  if (!isSubpath(absolutePath, projectRoot)) {
-    return "ssr";
-  }
-  const relative = toPosixPath(path.relative(projectRoot, absolutePath));
-  if (relative.startsWith("src/api/") || relative.includes("/src/api/")) {
-    return "api";
-  }
-  if (relative.startsWith("src/worker/") || relative.includes("/src/worker/")) {
-    return "worker";
-  }
-  if (relative.startsWith("src/server/") || relative.includes("/src/server/")) {
-    return "ssr";
-  }
-  if (relative.startsWith("build/dist/api/") || relative.includes("/build/dist/api/")) {
-    return "api";
-  }
-  if (relative.startsWith("build/dist/worker/") || relative.includes("/build/dist/worker/")) {
-    return "worker";
-  }
-  if (relative.startsWith("build/dist/ssr/") || relative.includes("/build/dist/ssr/")) {
-    return "ssr";
-  }
-  return "ssr";
-};
-function registerDevCoverageEndpoints(app) {
-  app.post("/api/dev/coverage/start", async (_req, res) => {
-    if (process.env.NODE_ENV === "production") {
-      res.status(404).json({ error: "Not Found" });
-      return;
-    }
-    if (activeRun) {
-      res.json({ ok: true, status: "already_started", startedAt: activeRun.startedAt });
-      return;
-    }
-    const roots = {
-      projectRoot: path.resolve(process.cwd()),
-      workspaceRoot: findWorkspaceRoot(process.cwd())
-    };
-    const session2 = new inspector.Session();
-    session2.connect();
-    try {
-      await post(session2, "Debugger.enable");
-      await post(session2, "Profiler.enable");
-      await post(session2, "Profiler.startPreciseCoverage", { callCount: false, detailed: true });
-      activeRun = {
-        roots,
-        session: session2,
-        sourceCache: /* @__PURE__ */ new Map(),
-        startedAt: Date.now()
-      };
-      res.json({ ok: true, status: "started", startedAt: activeRun.startedAt });
-    } catch (error) {
-      await shutdownSession(session2);
-      activeRun = null;
-      res.status(500).json({ ok: false, error: describeError(error) });
-    }
-  });
-  app.post("/api/dev/coverage/stop", async (req, res) => {
-    if (process.env.NODE_ENV === "production") {
-      res.status(404).json({ error: "Not Found" });
-      return;
-    }
-    const run = activeRun;
-    if (!run) {
-      res.status(409).json({ ok: false, error: "coverage_not_started" });
-      return;
-    }
-    activeRun = null;
-    const outputRoot = path.join(run.roots.projectRoot, "build", "coverage", "server");
-    const outputFiles = {
-      api: path.join(outputRoot, "api", "v8-coverage.json"),
-      worker: path.join(outputRoot, "worker", "v8-coverage.json"),
-      ssr: path.join(outputRoot, "ssr", "v8-coverage.json")
-    };
-    try {
-      const taken = await post(run.session, "Profiler.takePreciseCoverage");
-      const result = Array.isArray(taken?.result) ? taken.result : [];
-      const scriptsByTarget = {
-        api: [],
-        worker: [],
-        ssr: []
-      };
-      for (const entry of result) {
-        const scriptId = typeof entry?.scriptId === "string" ? entry.scriptId : null;
-        const url = typeof entry?.url === "string" ? entry.url : null;
-        if (!scriptId || !url) {
-          continue;
-        }
-        const normalized = await normalizeScriptUrl(url, run.roots);
-        if (!normalized) {
-          continue;
-        }
-        const source = await resolveScriptSource(run.session, run.sourceCache, scriptId);
-        const script = {
-          absolutePath: normalized.absolutePath,
-          relativePath: normalized.relativePath,
-          source,
-          functions: Array.isArray(entry?.functions) ? entry.functions : [],
-          url
-        };
-        const target = classifyServerTarget(script.absolutePath, run.roots.projectRoot);
-        scriptsByTarget[target].push(script);
-      }
-      await Promise.all(
-        Object.keys(outputFiles).map(async (target) => {
-          const outputFile = outputFiles[target];
-          const payload = {
-            testId: `node-${target}`,
-            scripts: scriptsByTarget[target]
-          };
-          await fsPromises.mkdir(path.dirname(outputFile), { recursive: true });
-          await fsPromises.writeFile(outputFile, JSON.stringify(payload, null, 2), "utf8");
-        })
-      );
-      res.json({
-        ok: true,
-        status: "stopped",
-        outputFiles,
-        scriptCount: {
-          api: scriptsByTarget.api.length,
-          worker: scriptsByTarget.worker.length,
-          ssr: scriptsByTarget.ssr.length
-        }
-      });
-    } catch (error) {
-      res.status(500).json({ ok: false, error: describeError(error) });
-    } finally {
-      await shutdownSession(run.session);
-    }
-  });
-}
-process.env = {
-  ...env,
-  ...__rb_env__,
-  ...process.env
-};
-const isProduction$1 = process.env.NODE_ENV === "production";
-const SESSION_MAX_AGE_S = 3600 * 24 * 60;
-const getMongoUrl = (serverEnv) => {
-  const explicitUrl = serverEnv.MONGODB_URL || serverEnv.MONGO_URL || serverEnv.MONGODB_URI || serverEnv.DB_URL;
-  if (explicitUrl) {
-    return explicitUrl;
-  }
-  if (serverEnv.DB_PORT) {
-    const host = serverEnv.DB_HOST ?? "localhost";
-    const appName = serverEnv.APP_NAME?.trim();
-    if (!appName) {
-      throw new Error("Missing APP_NAME (required to build MongoDB session store DB name)");
-    }
-    return `mongodb://${host}:${serverEnv.DB_PORT}/${appName}-sessions`;
-  }
-  return void 0;
-};
-const createMongoSessionStore = async (serverEnv) => {
-  const mongoUrl = getMongoUrl(serverEnv);
-  if (!mongoUrl) {
-    throw new Error("Missing REDIS_URL and Mongo connection details (MONGODB_URL/MONGO_URL/MONGODB_URI/DB_PORT)");
-  }
-  console.log("Using MongoDB session store");
-  const client2 = await MongoClient.connect(mongoUrl, {
-    family: 4,
-    serverSelectionTimeoutMS: 2e3,
-    connectTimeoutMS: 2e3
-  });
-  const store = MongoStore.create({
-    client: client2,
-    collectionName: "sessions",
-    ttl: SESSION_MAX_AGE_S
-  });
-  await store.collectionP;
-  return store;
-};
-const createRedisSessionStore = async (redisUrl) => {
-  const reconnectStrategy = (retries) => {
-    console.log("redis_client::rb/server reconnectStrategy::retrying with arg", retries);
-    if (retries < 5) {
-      console.log("retry count:", retries, "retrying in 1s");
-      return 4e3;
-    } else {
-      return new Error("max retries expired");
-    }
-  };
-  const redisClient = createClient({
-    url: redisUrl,
-    socket: {
-      reconnectStrategy,
-      connectTimeout: 1e4,
-      keepAlive: false
-    }
-  });
-  redisClient.on("ready", () => {
-    console.log("session-storage::redis_client connected");
-  });
-  redisClient.on("error", (error) => {
-    console.log("session-storage::redis_client ERROR", error);
-  });
-  console.log("Using Redis session store");
-  await redisClient.connect();
-  return new RedisStore({
-    client: redisClient,
-    ttl: SESSION_MAX_AGE_S
-  });
-};
-const initServer = async (app, serverEnv) => {
-  await initApiClient({ app });
-  const replicaSetInitPromise = checkInitReplicaSet(serverEnv).catch((error) => {
-    const message = error instanceof Error ? error.message : String(error);
-    console.warn(`[rb/server] MongoDB replica set auto-init error: ${message}`);
-  });
-  app.disable("x-powered-by");
-  app.set("trust proxy", true);
-  app.use(requestIp.mw());
-  app.use((req, res, next) => {
-    if (req.headers.host?.startsWith("www.")) {
-      const newHost = req.headers.host.replace("www.", "");
-      return res.redirect(301, `${req.protocol}://${newHost}${req.originalUrl}`);
-    }
-    next();
-  });
-  metricsIngestProxyMiddleware(app);
-  const posthog = getPosthogClient(serverEnv);
-  if (posthog) {
-    app.locals.posthog = posthog;
-    bindExpressErrorHandler(app, posthog);
-    ensurePosthogShutdown();
-  }
-  if (!serverEnv.MASTER_KEY) {
-    throw new Error("MASTER_KEY must be defined to derive the session secret");
-  }
-  const sessionSecret = getDerivedKey(serverEnv.MASTER_KEY, "express_session_key");
-  const redisUrl = serverEnv.REDIS_URL?.trim();
-  let store;
-  if (redisUrl) {
-    store = await createRedisSessionStore(redisUrl);
-  } else {
-    await replicaSetInitPromise;
-    store = await createMongoSessionStore(serverEnv);
-  }
-  const sessionConfig = {
-    name: "session",
-    store,
-    proxy: true,
-    resave: false,
-    saveUninitialized: false,
-    secret: sessionSecret,
-    cookie: {
-      maxAge: SESSION_MAX_AGE_S * 1e3
-    }
-  };
-  if (isProduction$1) {
-    sessionConfig.cookie.secure = "auto";
-  }
-  const sessionMiddleware = session(sessionConfig);
-  if (!isProduction$1) {
-    registerDevCoverageEndpoints(app);
-  }
-  app.use(sessionMiddleware);
-  return {
-    sessionMiddleware
-  };
-};
-async function hashPassword(password, salt) {
-  const keyLength = 64;
-  const options = {
-    N: 8192,
-    // CPU/memory cost parameter
-    r: 8,
-    // Block size
-    p: 1
-    // Parallelization factor
-  };
-  const derivedKey = await new Promise((resolve, reject) => {
-    scrypt(password, salt, keyLength, options, (err, derivedKey2) => {
-      if (err) {
-        reject(err);
-      } else {
-        resolve(derivedKey2);
-      }
-    });
-  });
-  return derivedKey;
-}
-const DEFAULT_SCRYPT_N = 8192;
-const DEFAULT_SCRYPT_R = 8;
-const DEFAULT_SCRYPT_P = 4;
-const DEFAULT_SCRYPT_KEYLEN = 64;
-const DEFAULT_SCRYPT_SALT_BYTES = 16;
-const DEFAULT_SCRYPT_MAXMEM_BYTES = 256 * 1024 * 1024;
-const MAX_SCRYPT_MAXMEM_BYTES = 1024 * 1024 * 1024;
-const MAX_SCRYPT_N = 1048576;
-const MAX_SCRYPT_R = 64;
-const MAX_SCRYPT_P = 16;
-const MAX_SCRYPT_KEYLEN = 128;
-const MAX_SCRYPT_SALT_BYTES = 64;
-const parseEnvInt = (value) => {
-  if (typeof value !== "string") return void 0;
-  const trimmed = value.trim();
-  if (!trimmed) return void 0;
-  const parsed = Number(trimmed);
-  if (!Number.isSafeInteger(parsed)) return void 0;
-  return parsed;
-};
-const isPowerOfTwo = (value) => (value & value - 1) === 0;
-const estimateScryptMemoryBytes = ({ N, r, p }) => {
-  return 128 * r * (N + p);
-};
-const validateScryptParams = (params) => {
-  const { N, r, p, keylen, saltBytes, maxmemBytes } = params;
-  if (!Number.isSafeInteger(N) || N < 2 || N > MAX_SCRYPT_N || !isPowerOfTwo(N)) {
-    return { ok: false, error: "invalid_scrypt_N" };
-  }
-  if (!Number.isSafeInteger(r) || r < 1 || r > MAX_SCRYPT_R) {
-    return { ok: false, error: "invalid_scrypt_r" };
-  }
-  if (!Number.isSafeInteger(p) || p < 1 || p > MAX_SCRYPT_P) {
-    return { ok: false, error: "invalid_scrypt_p" };
-  }
-  if (!Number.isSafeInteger(keylen) || keylen < 16 || keylen > MAX_SCRYPT_KEYLEN) {
-    return { ok: false, error: "invalid_scrypt_keylen" };
-  }
-  if (!Number.isSafeInteger(saltBytes) || saltBytes < 8 || saltBytes > MAX_SCRYPT_SALT_BYTES) {
-    return { ok: false, error: "invalid_scrypt_salt_bytes" };
-  }
-  if (!Number.isSafeInteger(maxmemBytes) || maxmemBytes < 16 * 1024 * 1024 || maxmemBytes > MAX_SCRYPT_MAXMEM_BYTES) {
-    return { ok: false, error: "invalid_scrypt_maxmem" };
-  }
-  const estimatedMem = estimateScryptMemoryBytes({ N, r, p });
-  if (estimatedMem > maxmemBytes) {
-    return { ok: false, error: "scrypt_params_exceed_maxmem" };
-  }
-  return { ok: true };
-};
-const getCurrentMaxmemBytes = (opts) => {
-  const envMaxmemBytes = parseEnvInt(process.env.RB_PASSWORD_SCRYPT_MAXMEM_BYTES);
-  const maxmemBytes = opts?.maxmemBytes ?? envMaxmemBytes ?? DEFAULT_SCRYPT_MAXMEM_BYTES;
-  if (!Number.isSafeInteger(maxmemBytes) || maxmemBytes < 16 * 1024 * 1024 || maxmemBytes > MAX_SCRYPT_MAXMEM_BYTES) {
-    throw new Error("invalid_scrypt_maxmem");
-  }
-  return maxmemBytes;
-};
-const getCurrentScryptParams = (opts) => {
-  const envN = parseEnvInt(process.env.RB_PASSWORD_SCRYPT_N);
-  const envR = parseEnvInt(process.env.RB_PASSWORD_SCRYPT_R);
-  const envP = parseEnvInt(process.env.RB_PASSWORD_SCRYPT_P);
-  const envKeylen = parseEnvInt(process.env.RB_PASSWORD_SCRYPT_KEYLEN);
-  const envSaltBytes = parseEnvInt(process.env.RB_PASSWORD_SCRYPT_SALT_BYTES);
-  const params = {
-    N: opts?.N ?? envN ?? DEFAULT_SCRYPT_N,
-    r: opts?.r ?? envR ?? DEFAULT_SCRYPT_R,
-    p: opts?.p ?? envP ?? DEFAULT_SCRYPT_P,
-    keylen: opts?.keylen ?? envKeylen ?? DEFAULT_SCRYPT_KEYLEN,
-    saltBytes: opts?.saltBytes ?? envSaltBytes ?? DEFAULT_SCRYPT_SALT_BYTES,
-    maxmemBytes: getCurrentMaxmemBytes(opts)
-  };
-  const validated = validateScryptParams(params);
-  if (!validated.ok) {
-    throw new Error(validated.error);
-  }
-  return params;
-};
-const scryptAsync = async (password, salt, params) => {
-  const { N, r, p, keylen, maxmemBytes } = params;
-  return await new Promise((resolve, reject) => {
-    crypto.scrypt(password, salt, keylen, { N, r, p, maxmem: maxmemBytes }, (err, derivedKey) => {
-      if (err) {
-        reject(err);
-        return;
-      }
-      resolve(derivedKey);
-    });
-  });
-};
-const base64Regex = /^[A-Za-z0-9+/]+={0,2}$/;
-const parseB64 = (value) => {
-  if (!value) return null;
-  if (!base64Regex.test(value)) return null;
-  if (value.length % 4 !== 0) return null;
-  const buf = Buffer.from(value, "base64");
-  if (buf.length === 0) return null;
-  if (buf.toString("base64") !== value) return null;
-  return buf;
-};
-const MAX_STORED_PASSWORD_LENGTH = 1024;
-const MAX_STORED_PASSWORD_SECTION_LENGTH = 256;
-const parseStoredScryptHash = (stored) => {
-  if (stored.length > MAX_STORED_PASSWORD_LENGTH) return null;
-  const parts = stored.split("$");
-  if (parts.length !== 5) return null;
-  if (parts[0] !== "" || parts[1] !== "scrypt") return null;
-  const paramsStr = parts[2];
-  const saltB64 = parts[3];
-  const dkB64 = parts[4];
-  if (paramsStr.length > MAX_STORED_PASSWORD_SECTION_LENGTH) return null;
-  if (saltB64.length > MAX_STORED_PASSWORD_SECTION_LENGTH) return null;
-  if (dkB64.length > MAX_STORED_PASSWORD_SECTION_LENGTH) return null;
-  const kvPairs = paramsStr.split(",").filter(Boolean);
-  if (kvPairs.length === 0) return null;
-  const params = /* @__PURE__ */ new Map();
-  for (const pair of kvPairs) {
-    const idx = pair.indexOf("=");
-    if (idx <= 0 || idx === pair.length - 1) return null;
-    const key = pair.slice(0, idx);
-    const valueRaw = pair.slice(idx + 1);
-    if (!/^[a-zA-Z0-9]+$/.test(key)) return null;
-    if (params.has(key)) return null;
-    const value = Number(valueRaw);
-    if (!Number.isSafeInteger(value)) return null;
-    params.set(key, value);
-  }
-  const N = params.get("N");
-  const r = params.get("r");
-  const p = params.get("p");
-  const keylen = params.get("keylen");
-  if (N === void 0 || r === void 0 || p === void 0 || keylen === void 0) return null;
-  if (params.size !== 4) return null;
-  const salt = parseB64(saltB64);
-  const dk = parseB64(dkB64);
-  if (!salt || !dk) return null;
-  if (dk.length !== keylen) return null;
-  if (salt.length < 8 || salt.length > MAX_SCRYPT_SALT_BYTES) return null;
-  if (dk.length < 16 || dk.length > MAX_SCRYPT_KEYLEN) return null;
-  const currentMaxmemBytes = getCurrentMaxmemBytes();
-  const validated = validateScryptParams({
-    N,
-    r,
-    p,
-    keylen,
-    saltBytes: salt.length,
-    maxmemBytes: currentMaxmemBytes
-  });
-  if (!validated.ok) return null;
-  return { N, r, p, keylen, salt, dk };
-};
-async function hashPasswordForStorage(password, opts) {
-  const { N, r, p, keylen, saltBytes, maxmemBytes } = getCurrentScryptParams(opts);
-  const salt = crypto.randomBytes(saltBytes);
-  const dk = await scryptAsync(password, salt, { N, r, p, keylen, maxmemBytes });
-  const saltB64 = salt.toString("base64");
-  const dkB64 = dk.toString("base64");
-  return `$scrypt$N=${N},r=${r},p=${p},keylen=${keylen}$${saltB64}$${dkB64}`;
-}
-async function verifyPasswordFromStorage(password, stored) {
-  const parsed = parseStoredScryptHash(stored);
-  if (!parsed) return false;
-  const { N, r, p, keylen, salt, dk } = parsed;
-  const maxmemBytes = getCurrentMaxmemBytes();
-  let derivedKey;
-  try {
-    derivedKey = await scryptAsync(password, salt, { N, r, p, keylen, maxmemBytes });
-  } catch {
-    return false;
-  }
-  if (derivedKey.length !== dk.length) return false;
-  return crypto.timingSafeEqual(dk, derivedKey);
-}
-function createLocation(current, to, state = null, key) {
-  const location = {
-    pathname: current,
-    search: "",
-    hash: "",
-    ...typeof to === "string" ? parsePath(to) : to,
-    state,
-    // TODO: This could be cleaned up.  push/replace should probably just take
-    // full Locations now and avoid the need to run through this flow at all
-    // But that's a pretty big refactor to the current test suite so going to
-    // keep as is for the time being and just let any incoming keys take precedence
-    key: to && to.key || key
-  };
-  return location;
-}
-function getShortCircuitMatches(routes) {
-  const route = routes.length === 1 ? routes[0] : routes.find((r) => r.index || !r.path || r.path === "/") || {
-    id: "__shim-error-route__"
-  };
-  return {
-    matches: [
-      {
-        params: {},
-        pathname: "",
-        pathnameBase: "",
-        route
-      }
-    ],
-    route
-  };
-}
-const NOT_FOUND_STATUS = 404;
-const LOADER_TIMEOUT_MS = 4e3;
-const getErrorStatus = (error) => {
-  if (!error) return void 0;
-  const candidate = error?.reason ?? error;
-  if (typeof candidate?.status === "number") return candidate.status;
-  if (typeof candidate?.statusCode === "number") return candidate.statusCode;
-  if (typeof candidate?.response?.status === "number") return candidate.response.status;
-  return void 0;
-};
-const isResponseLike = (value) => {
-  return Boolean(
-    value && typeof value === "object" && typeof value.status === "number" && value.headers && typeof value.headers.get === "function"
-  );
-};
-const isRedirectResponse = (value) => {
-  if (!isResponseLike(value)) return false;
-  return value.status >= 300 && value.status < 400 && Boolean(value.headers.get("Location"));
-};
-const getRouteHandleStatusCode = (route) => {
-  if (!route) return void 0;
-  const handle = route.handle;
-  if (!handle) return void 0;
-  const candidate = handle.statusCode ?? handle.status ?? handle.httpStatus;
-  if (typeof candidate === "number") return candidate;
-  return void 0;
-};
-const isNotFoundFallbackRoute = (route) => {
-  if (!route) return false;
-  if (route.path !== "*") return false;
-  if (route.loader) return false;
-  if (route.action) return false;
-  if (route.children?.length) return false;
-  return true;
-};
-async function applyRouteLoaders(req, dataRoutes) {
-  const baseUrl = `${req.protocol}://${req.get("host")}`;
-  const url = new URL(req.originalUrl, baseUrl);
-  const method = req.method;
-  const location = createLocation("", createPath(url), null, "default");
-  const baseContext = {
-    basename: "",
-    location,
-    loaderHeaders: {},
-    actionHeaders: {}
-  };
-  const matches = matchRoutes(dataRoutes, location);
-  if (!matches || matches.length === 0) {
-    const error = {
-      status: 404,
-      message: `No route matches URL: ${req.originalUrl}`
-    };
-    const { matches: notFoundMatches, route } = getShortCircuitMatches(dataRoutes);
-    return {
-      ...baseContext,
-      matches: notFoundMatches,
-      loaderData: {},
-      actionData: null,
-      errors: { [route.id]: error },
-      statusCode: 404
-    };
-  }
-  if (method !== "GET") {
-    return {
-      ...baseContext,
-      matches,
-      loaderData: {},
-      actionData: null,
-      errors: null,
-      statusCode: 200
-    };
-  }
-  const runLoaderWithTimeout = async (route, params) => {
-    if (!route.loader) return null;
-    let timeoutId;
-    const timeoutPromise = new Promise((_, reject) => {
-      timeoutId = setTimeout(() => {
-        const err = new Error(`Loader timeout after ${LOADER_TIMEOUT_MS}ms`);
-        err.status = 504;
-        console.error("[rpcbase timeout][server loader]", {
-          routeId: route.id,
-          ms: LOADER_TIMEOUT_MS,
-          url: req.originalUrl
-        });
-        reject({ id: route.id, path: route.path, reason: err });
-      }, LOADER_TIMEOUT_MS);
-    });
-    const loaderPromise = (async () => {
-      try {
-        const data = await route.loader({
-          params,
-          ctx: { req }
-        });
-        return { id: route.id, path: route.path, data };
-      } catch (error) {
-        throw { id: route.id, path: route.path, reason: error };
-      } finally {
-        if (timeoutId) {
-          clearTimeout(timeoutId);
-        }
-      }
-    })();
-    return Promise.race([loaderPromise, timeoutPromise]);
-  };
-  const loaderPromisesResults = await Promise.allSettled(
-    matches.map((match) => runLoaderWithTimeout(match.route, match.params))
-  );
-  const loaderData = {};
-  let errors = null;
-  let hasNotFoundError = false;
-  let hasNonNotFoundError = false;
-  let redirectResponse = null;
-  let redirectRouteId = null;
-  let redirectRoutePath = null;
-  for (const result of loaderPromisesResults) {
-    if (result.status === "fulfilled") {
-      if (result.value) {
-        if (isRedirectResponse(result.value.data)) {
-          redirectResponse = result.value.data;
-          redirectRouteId = result.value.id;
-          redirectRoutePath = result.value.path ?? null;
-        } else {
-          loaderData[result.value.id] = result.value.data;
-        }
-      }
-    } else if (result.status === "rejected") {
-      const id = result.reason?.id;
-      if (!id) {
-        throw new Error(
-          `missing route ID in error: ${result.reason}`
-        );
-      }
-      const reasonCandidate = result.reason?.reason ?? result.reason;
-      if (isRedirectResponse(reasonCandidate)) {
-        redirectResponse = reasonCandidate;
-        redirectRouteId = id;
-        redirectRoutePath = result.reason?.path ?? null;
-        continue;
-      }
-      if (!errors) {
-        errors = {};
-      }
-      const status = getErrorStatus(result.reason);
-      if (status === NOT_FOUND_STATUS) {
-        hasNotFoundError = true;
-      } else {
-        hasNonNotFoundError = true;
-      }
-      errors[id] = result.reason;
-    }
-  }
-  if (redirectResponse) {
-    return {
-      ...baseContext,
-      matches,
-      loaderData,
-      actionData: null,
-      errors: null,
-      statusCode: redirectResponse.status,
-      redirectResponse,
-      redirectRouteId,
-      redirectRoutePath
-    };
-  }
-  let statusCode = 200;
-  if (errors) {
-    if (hasNonNotFoundError) {
-      statusCode = 500;
-    } else if (hasNotFoundError) {
-      statusCode = NOT_FOUND_STATUS;
-    } else {
-      statusCode = 500;
-    }
-  }
-  if (!errors && statusCode === 200) {
-    const leafRoute = matches.at(-1)?.route;
-    const handleStatusCode = getRouteHandleStatusCode(leafRoute);
-    if (typeof handleStatusCode === "number") {
-      statusCode = handleStatusCode;
-    } else if (isNotFoundFallbackRoute(leafRoute)) {
-      statusCode = NOT_FOUND_STATUS;
-    }
-  }
-  return {
-    ...baseContext,
-    matches,
-    loaderData,
-    actionData: null,
-    errors,
-    statusCode
-  };
-}
-async function renderSSR(req, dataRoutes) {
-  const routerContext = await applyRouteLoaders(req, dataRoutes);
-  const isMatched = routerContext.matches.length > 0;
-  if (routerContext.redirectResponse) {
-    return {
-      element: null,
-      isMatched,
-      statusCode: routerContext.statusCode ?? routerContext.redirectResponse.status ?? 302,
-      redirectResponse: routerContext.redirectResponse,
-      redirectRouteId: routerContext.redirectRouteId,
-      redirectRoutePath: routerContext.redirectRoutePath
-    };
-  }
-  if (routerContext.errors) {
-    if (routerContext.statusCode === 404) {
-      console.warn(`SSR 404 ${req.method} ${req.originalUrl}`, {
-        errors: routerContext.errors
-      });
-    } else {
-      const matchesSummary = routerContext.matches?.map((m) => ({
-        routeId: m.route.id,
-        routePath: m.route.path,
-        pathname: m.pathname,
-        pathnameBase: m.pathnameBase
-      }));
-      console.error(
-        `SSR ${routerContext.statusCode || 500} ${req.method} ${req.originalUrl}`,
-        {
-          errors: routerContext.errors,
-          matches: matchesSummary
-        }
-      );
-      const errorEntries = Object.entries(routerContext.errors || {});
-      const firstErrorEntry = errorEntries[0]?.[1];
-      const firstReason = firstErrorEntry?.reason ?? firstErrorEntry;
-      if (errorEntries.length === 1 && firstReason instanceof Error) {
-        firstReason.details = routerContext.errors;
-        throw firstReason;
-      }
-      const extra = firstErrorEntry?.id ? ` (route ${firstErrorEntry.id}${firstErrorEntry?.path ? ` ${firstErrorEntry.path}` : ""})` : "";
-      const error = new Error(`SSR loader error${extra}`);
-      error.details = routerContext.errors;
-      throw error;
-    }
-  }
-  const router = createStaticRouter(dataRoutes, routerContext);
-  const element = /* @__PURE__ */ jsx(StrictMode, { children: /* @__PURE__ */ jsx(
-    StaticRouterProvider,
-    {
-      router,
-      context: routerContext
-    }
-  ) });
-  return {
-    element,
-    isMatched,
-    statusCode: routerContext.statusCode ?? (routerContext.errors ? 500 : 200)
-  };
-}
-const ABORT_DELAY_MS = 1e4;
-const APP_HTML_PLACEHOLDER = "<!--app-html-->";
-const DEFAULT_SERVER_ERROR_MESSAGE = "We couldn't render this page on the server. Please refresh and try again.";
-const FALLBACK_ERROR_TEMPLATE_START = `<!doctype html><html lang="en"><head><meta charset="UTF-8" /><meta name="viewport" content="width=device-width,initial-scale=1" /><title>Server error</title><style>body{margin:0;font-family:-apple-system,BlinkMacSystemFont,'Segoe UI',sans-serif;background:#0b1021;color:#eef1f7;display:flex;align-items:center;justify-content:center;min-height:100vh;}main{max-width:420px;padding:32px;background:rgba(255,255,255,0.04);border:1px solid rgba(255,255,255,0.08);border-radius:14px;box-shadow:0 25px 50px rgba(0,0,0,0.35);}h1{font-size:24px;margin:0 0 8px;}p{margin:0 0 12px;line-height:1.5;}code{background:rgba(255,255,255,0.08);padding:2px 6px;border-radius:6px;font-size:12px;}</style></head><body><main>`;
-const FALLBACK_ERROR_TEMPLATE_END = "</main></body></html>";
-const isProduction = env.NODE_ENV === "production";
-const templateHtml = isProduction ? readFileSync("./build/dist/client/src/client/index.html", "utf-8") : "";
-const handleRedirectionResponse = (res, redirectResponse, location) => {
-  res.status(redirectResponse.status || 302);
-  try {
-    const headers = redirectResponse.headers;
-    const setCookies = headers.getSetCookie?.();
-    const fallbackSetCookies = [];
-    for (const [key, value] of headers) {
-      if (key.toLowerCase() === "set-cookie") {
-        if (!setCookies?.length) {
-          fallbackSetCookies.push(value);
-        }
-        continue;
-      }
-      res.setHeader(key, value);
-    }
-    if (setCookies?.length) {
-      res.setHeader("Set-Cookie", setCookies);
-    } else if (fallbackSetCookies.length === 1) {
-      res.setHeader("Set-Cookie", fallbackSetCookies[0]);
-    } else if (fallbackSetCookies.length > 1) {
-      res.setHeader("Set-Cookie", fallbackSetCookies);
-    }
-  } catch {
-  }
-  if (location) res.setHeader("Location", location);
-  res.end();
-};
-const formatErrorDetails = (error) => {
-  if (isProduction) return void 0;
-  if (!error) return void 0;
-  if (error instanceof Error) {
-    return error.stack || error.message;
-  }
-  if (typeof error === "string") {
-    return error;
-  }
-  try {
-    return JSON.stringify(error, null, 2);
-  } catch {
-    return void 0;
-  }
-};
-const sendErrorResponse = ({
-  res,
-  htmlStart,
-  htmlEnd,
-  error,
-  status = 500,
-  title = "Server rendering error",
-  message = DEFAULT_SERVER_ERROR_MESSAGE,
-  errorExtraComponent
-}) => {
-  if (res.headersSent) return;
-  const start = htmlStart ?? FALLBACK_ERROR_TEMPLATE_START;
-  const end = htmlEnd ?? FALLBACK_ERROR_TEMPLATE_END;
-  res.status(status);
-  res.set({ "Content-Type": "text/html" });
-  const details = formatErrorDetails(error);
-  const state = {
-    statusCode: status,
-    title,
-    message,
-    details
-  };
-  const markup = renderToStaticMarkup(
-    createElement(
-      StrictMode,
-      null,
-      createElement(SsrErrorFallback, {
-        state,
-        renderErrorExtra: errorExtraComponent ? (payload) => createElement(errorExtraComponent, { state: payload }) : void 0
-      })
-    )
-  );
-  const serializedState = `<script>window.${SSR_ERROR_STATE_GLOBAL_KEY}=${serializeSsrErrorState({
-    ...state,
-    details: isProduction ? void 0 : details
-  })};<\/script>`;
-  res.end(`${start}${markup}${serializedState}${end}`);
-};
-const ssrMiddleware = ({
-  viteInstance,
-  dataRoutes,
-  errorExtraComponent,
-  renderTemplateStart,
-  posthog
-}) => async (req, res, next) => {
-  let template;
-  let htmlStart = null;
-  let htmlEnd = null;
-  let responseCommitted = false;
-  const posthogClient = posthog ?? req.app?.locals?.posthog ?? null;
-  const captureException = (error, extra) => {
-    if (!error) return;
-    captureServerException(error, posthogClient, {
-      path: req.originalUrl,
-      method: req.method,
-      source: "ssrMiddleware",
-      ...extra
-    });
-  };
-  const finalizeWithErrorPage = (error, status = 500, message = DEFAULT_SERVER_ERROR_MESSAGE) => {
-    if (responseCommitted) return;
-    sendErrorResponse({
-      res,
-      htmlStart,
-      htmlEnd,
-      error,
-      status,
-      message,
-      errorExtraComponent
-    });
-    responseCommitted = true;
-    if (error) {
-      captureException(error, { phase: "finalizeWithErrorPage" });
-    }
-  };
-  try {
-    const base = "/";
-    const url = req.originalUrl.replace(base, "");
-    if (isProduction) {
-      template = templateHtml;
-    } else {
-      template = await fsPromises.readFile("./src/client/index.html", "utf-8");
-      template = await viteInstance.transformIndexHtml(url, template);
-    }
-    const placeholderIndex = template.indexOf(APP_HTML_PLACEHOLDER);
-    if (placeholderIndex === -1) {
-      throw new Error(`Template missing ${APP_HTML_PLACEHOLDER} placeholder`);
-    }
-    const templateStart = template.slice(0, placeholderIndex);
-    if (renderTemplateStart) {
-      htmlStart = await renderTemplateStart(req, templateStart);
-    } else {
-      htmlStart = templateStart;
-    }
-    htmlEnd = template.slice(placeholderIndex + APP_HTML_PLACEHOLDER.length);
-    const {
-      element,
-      isMatched,
-      statusCode,
-      redirectResponse,
-      redirectRouteId,
-      redirectRoutePath
-    } = await renderSSR(req, dataRoutes);
-    if (redirectResponse) {
-      if (!responseCommitted) {
-        const location = redirectResponse.headers?.get?.("Location");
-        if (!isProduction) {
-          console.info("SSR redirect", {
-            method: req.method,
-            url: req.originalUrl,
-            status: redirectResponse.status,
-            location,
-            routeId: redirectRouteId ?? void 0,
-            routePath: redirectRoutePath ?? void 0
-          });
-        }
-        responseCommitted = true;
-        handleRedirectionResponse(res, redirectResponse, location);
-      }
-      return;
-    }
-    if (!isMatched) {
-      next();
-      return;
-    }
-    let didError = false;
-    const { pipe, abort } = renderToPipeableStream(
-      element,
-      {
-        onShellError(error) {
-          if (error instanceof Error) {
-            viteInstance?.ssrFixStacktrace(error);
-          }
-          console.error("SSR shell error", error);
-          captureException(error, { phase: "shell" });
-          finalizeWithErrorPage(error);
-          abort();
-        },
-        onError(error) {
-          didError = true;
-          if (error instanceof Error) {
-            viteInstance?.ssrFixStacktrace(error);
-          }
-          console.error("SSR rendering error", error);
-          captureException(error, { phase: "render" });
-        },
-        onShellReady() {
-          if (responseCommitted) {
-            return;
-          }
-          if (!htmlStart || !htmlEnd) {
-            finalizeWithErrorPage();
-            return;
-          }
-          responseCommitted = true;
-          const responseStatus = didError ? 500 : statusCode || 200;
-          res.status(responseStatus);
-          res.set({ "Content-Type": "text/html" });
-          const transformStream = new Transform({
-            transform(chunk, encoding, callback) {
-              res.write(chunk, encoding);
-              callback();
-            }
-          });
-          const start = htmlStart;
-          const end = htmlEnd;
-          res.write(start);
-          transformStream.on("finish", () => {
-            res.end(end);
-          });
-          pipe(transformStream);
-        }
-      }
-    );
-    setTimeout(() => {
-      abort();
-    }, ABORT_DELAY_MS);
-  } catch (err) {
-    if (err instanceof Error) {
-      viteInstance?.ssrFixStacktrace(err);
-      console.error("SSR middleware error:", err.message);
-      console.error(err.stack);
-    } else {
-      console.error("Unknown SSR middleware error", err);
-    }
-    captureException(err, { phase: "catch" });
-    finalizeWithErrorPage(err);
-  }
-};
-export {
-  getDerivedKey,
-  hashPassword,
-  hashPasswordForStorage,
-  initServer,
-  s as sendEmail,
-  ssrMiddleware,
-  verifyPasswordFromStorage
-};
-//# sourceMappingURL=index.js.map