@rpcbase/server 0.546.0 → 0.548.0

package/dist/index.js

@@ -5,7 +5,8 @@ import { createClient } from "redis";
 import { MongoClient } from "mongodb";
 import env from "@rpcbase/env";
 import { initApiClient, STATIC_RPCBASE_RTS_HYDRATION_DATA_KEY, RtsSsrRuntimeProvider, SsrErrorFallback, SSR_ERROR_STATE_GLOBAL_KEY, serializeSsrErrorState } from "@rpcbase/client";
-import { posix, dirname, sep } from "path";
+import { getMongoUrl } from "@rpcbase/db/mongo";
+import { posix, dirname, sep, isAbsolute, relative } from "path";
 import fs, { createReadStream, readFileSync } from "node:fs";
 import { createInterface } from "node:readline";
 import { AsyncLocalStorage } from "node:async_hooks";
@@ -290,194 +291,23 @@ const parsePayload = (response) => {
     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;
-  }
+function isGzipSupported() {
+  return "CompressionStream" in globalThis;
 }
-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);
+async function gzipCompress(input, isDebug = true, options) {
+  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;
   }
 }
-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();
-var types_PostHogPersistedProperty = /* @__PURE__ */ (function(PostHogPersistedProperty) {
-  PostHogPersistedProperty["AnonymousId"] = "anonymous_id";
-  PostHogPersistedProperty["DistinctId"] = "distinct_id";
-  PostHogPersistedProperty["Props"] = "props";
-  PostHogPersistedProperty["EnablePersonProcessing"] = "enable_person_processing";
-  PostHogPersistedProperty["PersonMode"] = "person_mode";
-  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 DEFAULT_BLOCKED_UA_STRS = [
   "amazonbot",
   "amazonproductbot",
@@ -565,6 +395,37 @@ const isBlockedUA = function(ua, customBlockedUserAgents = []) {
     return -1 !== uaLower.indexOf(blockedUaLower);
   });
 };
+var types_PostHogPersistedProperty = /* @__PURE__ */ (function(PostHogPersistedProperty) {
+  PostHogPersistedProperty["AnonymousId"] = "anonymous_id";
+  PostHogPersistedProperty["DistinctId"] = "distinct_id";
+  PostHogPersistedProperty["Props"] = "props";
+  PostHogPersistedProperty["EnablePersonProcessing"] = "enable_person_processing";
+  PostHogPersistedProperty["PersonMode"] = "person_mode";
+  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";
+  PostHogPersistedProperty["DeviceId"] = "device_id";
+  return PostHogPersistedProperty;
+})({});
 const nativeIsArray = Array.isArray;
 const ObjProto = Object.prototype;
 const type_utils_toString = ObjProto.toString;
@@ -572,7 +433,6 @@ 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) && x === x;
@@ -584,7 +444,7 @@ function isBuiltin(candidate, className) {
   return Object.prototype.toString.call(candidate) === `[object ${className}]`;
 }
 function isEvent(candidate) {
-  return !isUndefined(Event) && isInstanceOf(candidate, Event);
+  return "undefined" != typeof Event && isInstanceOf(candidate, Event);
 }
 function isPlainObject(candidate) {
   return isBuiltin(candidate, "Object");
@@ -651,6 +511,164 @@ class BucketedRateLimiter {
     this._buckets = {};
   }
 }
+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();
 class PromiseQueue {
   add(promise) {
     const promiseUUID = uuidv7();
@@ -715,13 +733,6 @@ 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(/\/+$/, "");
 }
@@ -774,23 +785,6 @@ class SimpleEventEmitter {
     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";
@@ -836,9 +830,13 @@ class PostHogCoreStateless {
     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");
+    const normalizedApiKey = "string" == typeof apiKey ? apiKey.trim() : "";
+    const normalizedHost = "string" == typeof options.host ? options.host.trim() : "";
+    const missingApiKey = !normalizedApiKey;
+    this._logger = createLogger("[PostHog]", this.logMsgIfDebug.bind(this));
+    if (missingApiKey) this._logger.error("You must pass your PostHog project's api key. The client will be disabled.");
+    this.apiKey = normalizedApiKey;
+    this.host = removeTrailingSlash(normalizedHost || "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);
@@ -855,11 +853,10 @@ class PostHogCoreStateless {
     this.featureFlagsRequestTimeoutMs = options.featureFlagsRequestTimeoutMs ?? 3e3;
     this.remoteConfigRequestTimeoutMs = options.remoteConfigRequestTimeoutMs ?? 3e3;
     this.disableGeoip = options.disableGeoip ?? true;
-    this.disabled = options.disabled ?? false;
+    this.disabled = (options.disabled ?? false) || missingApiKey;
     this.historicalMigration = options?.historicalMigration ?? false;
     this._initPromise = Promise.resolve();
     this._isInitialized = true;
-    this._logger = createLogger("[PostHog]", this.logMsgIfDebug.bind(this));
     this.evaluationContexts = options?.evaluationContexts ?? options?.evaluationEnvironments;
     if (options?.evaluationEnvironments && !options?.evaluationContexts) this._logger.warn("evaluationEnvironments is deprecated. Use evaluationContexts instead. This property will be removed in a future version.");
     this.disableCompression = !isGzipSupported() || (options?.disableCompression ?? false);
@@ -1024,7 +1021,7 @@ class PostHogCoreStateless {
       this._events.emit("error", error);
     });
   }
-  async getFlags(distinctId, groups = {}, personProperties = {}, groupProperties = {}, extraPayload = {}, fetchConfig = true) {
+  async getFlags(distinctId, groups = {}, personProperties = {}, groupProperties = {}, extraPayload = {}, fetchConfig = false) {
     await this._initPromise;
     const configParam = fetchConfig ? "&config=true" : "";
     const url = `${this.host}/flags/?v=2${configParam}`;
@@ -1036,6 +1033,7 @@ class PostHogCoreStateless {
       group_properties: groupProperties,
       ...extraPayload
     };
+    if (personProperties.$device_id) requestData.$device_id = personProperties.$device_id;
     if (this.evaluationContexts && this.evaluationContexts.length > 0) requestData.evaluation_contexts = this.evaluationContexts;
     const fetchOptions = {
       method: "POST",
@@ -1383,11 +1381,6 @@ class PostHogCoreStateless {
     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 {
@@ -1400,14 +1393,19 @@ class PostHogCoreStateless {
       }
     }
     return await retriable(async () => {
+      const ctrl = new AbortController();
+      const timeoutMs = requestTimeout ?? this.requestTimeout;
+      const timer = safeSetTimeout(() => ctrl.abort(), timeoutMs);
       let res = null;
       try {
         res = await this.fetch(url, {
-          signal: AbortSignal.timeout(requestTimeout ?? this.requestTimeout),
+          signal: ctrl.signal,
           ...options
         });
       } catch (e) {
         throw new PostHogFetchNetworkError(e);
+      } finally {
+        clearTimeout(timer);
       }
       const isNoCors = "no-cors" === options.mode;
       if (!isNoCors && (res.status < 200 || res.status >= 400)) throw new PostHogFetchHttpError(res, reqByteLength);
@@ -1435,16 +1433,21 @@ class PostHogCoreStateless {
         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()
-    ]);
+    let timeoutHandle;
+    try {
+      return await Promise.race([
+        new Promise((_, reject) => {
+          timeoutHandle = 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()
+      ]);
+    } finally {
+      clearTimeout(timeoutHandle);
+    }
   }
   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");
@@ -2051,6 +2054,17 @@ function snipLine(line, colno) {
   if (end < lineLength) newLine += "...";
   return newLine;
 }
+function createRelativePathModifier(basePath = process.cwd()) {
+  const isWindows = "\\" === sep;
+  const toUnix = (p) => isWindows ? p.replace(/\\/g, "/") : p;
+  const normalizedBase = toUnix(basePath);
+  return async (frames) => {
+    for (const frame of frames) if (!(!frame.filename || frame.filename.startsWith("node:") || frame.filename.startsWith("data:"))) {
+      if (isAbsolute(frame.filename)) frame.filename = toUnix(relative(normalizedBase, toUnix(frame.filename)));
+    }
+    return frames;
+  };
+}
 function makeUncaughtExceptionHandler(captureFn, onFatalFn) {
   let calledFatalError = false;
   return Object.assign((error) => {
@@ -2102,12 +2116,11 @@ class ErrorTracking {
     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(),
+      distinctId,
       properties: {
         ...exceptionProperties,
         ...properties
@@ -2147,7 +2160,7 @@ class ErrorTracking {
     this._rateLimiter.stop();
   }
 }
-const version = "5.26.0";
+const version = "5.30.1";
 const FeatureFlagError = {
   ERRORS_WHILE_COMPUTING: "errors_while_computing_flags",
   FLAG_MISSING: "flag_missing",
@@ -2476,6 +2489,9 @@ class FeatureFlagsPoller {
   isLocalEvaluationReady() {
     return (this.loadedSuccessfullyOnce ?? false) && (this.featureFlags?.length ?? 0) > 0;
   }
+  getFlagDefinitionsLoadedAt() {
+    return this.flagDefinitionsLoadedAt;
+  }
   getPollingInterval() {
     if (!this.shouldBeginExponentialBackoff) return this.pollingInterval;
     return Math.min(SIXTY_SECONDS, this.pollingInterval * 2 ** this.backOffCount);
@@ -2543,6 +2559,7 @@ class FeatureFlagsPoller {
             cohorts: responseJson.cohorts || {}
           };
           this.updateFlagState(flagData);
+          this.flagDefinitionsLoadedAt = Date.now();
           this.clearBackoff();
           if (this.cacheProvider && shouldFetch) try {
             await this.cacheProvider.onFlagDefinitionsReceived(flagData);
@@ -2573,7 +2590,7 @@ class FeatureFlagsPoller {
     };
   }
   _requestFeatureFlagDefinitions() {
-    const url = `${this.host}/api/feature_flag/local_evaluation?token=${this.projectApiKey}&send_cohorts`;
+    const url = `${this.host}/flags/definitions?token=${this.projectApiKey}&send_cohorts`;
     const options = this.getPersonalApiKeyRequestOptions("GET", this.flagsEtag);
     let abortTimeout = null;
     if (this.timeout && "number" == typeof this.timeout) {
@@ -2670,6 +2687,45 @@ function matchProperty(property, propertyValues, warnFunction) {
       ].includes(operator)) return overrideDate < parsedDate;
       return overrideDate > parsedDate;
     }
+    case "semver_eq": {
+      const cmp = compareSemverTuples(parseSemver(String(overrideValue)), parseSemver(String(value)));
+      return 0 === cmp;
+    }
+    case "semver_neq": {
+      const cmp = compareSemverTuples(parseSemver(String(overrideValue)), parseSemver(String(value)));
+      return 0 !== cmp;
+    }
+    case "semver_gt": {
+      const cmp = compareSemverTuples(parseSemver(String(overrideValue)), parseSemver(String(value)));
+      return cmp > 0;
+    }
+    case "semver_gte": {
+      const cmp = compareSemverTuples(parseSemver(String(overrideValue)), parseSemver(String(value)));
+      return cmp >= 0;
+    }
+    case "semver_lt": {
+      const cmp = compareSemverTuples(parseSemver(String(overrideValue)), parseSemver(String(value)));
+      return cmp < 0;
+    }
+    case "semver_lte": {
+      const cmp = compareSemverTuples(parseSemver(String(overrideValue)), parseSemver(String(value)));
+      return cmp <= 0;
+    }
+    case "semver_tilde": {
+      const overrideParsed = parseSemver(String(overrideValue));
+      const { lower, upper } = computeTildeBounds(String(value));
+      return compareSemverTuples(overrideParsed, lower) >= 0 && compareSemverTuples(overrideParsed, upper) < 0;
+    }
+    case "semver_caret": {
+      const overrideParsed = parseSemver(String(overrideValue));
+      const { lower, upper } = computeCaretBounds(String(value));
+      return compareSemverTuples(overrideParsed, lower) >= 0 && compareSemverTuples(overrideParsed, upper) < 0;
+    }
+    case "semver_wildcard": {
+      const overrideParsed = parseSemver(String(overrideValue));
+      const { lower, upper } = computeWildcardBounds(String(value));
+      return compareSemverTuples(overrideParsed, lower) >= 0 && compareSemverTuples(overrideParsed, upper) < 0;
+    }
     default:
       throw new InconclusiveMatchError(`Unknown operator: ${operator}`);
   }
@@ -2738,6 +2794,115 @@ function isValidRegex(regex) {
     return false;
   }
 }
+function parseSemver(value) {
+  const text = String(value).trim().replace(/^[vV]/, "");
+  const baseVersion = text.split("-")[0].split("+")[0];
+  if (!baseVersion || baseVersion.startsWith(".")) throw new InconclusiveMatchError(`Invalid semver: ${value}`);
+  const parts = baseVersion.split(".");
+  const parsePart = (part) => {
+    if (void 0 === part || "" === part) return 0;
+    if (!/^\d+$/.test(part)) throw new InconclusiveMatchError(`Invalid semver: ${value}`);
+    return parseInt(part, 10);
+  };
+  const major = parsePart(parts[0]);
+  const minor = parsePart(parts[1]);
+  const patch = parsePart(parts[2]);
+  return [
+    major,
+    minor,
+    patch
+  ];
+}
+function compareSemverTuples(a, b) {
+  for (let i = 0; i < 3; i++) {
+    if (a[i] < b[i]) return -1;
+    if (a[i] > b[i]) return 1;
+  }
+  return 0;
+}
+function computeTildeBounds(value) {
+  const parsed = parseSemver(value);
+  const lower = [
+    parsed[0],
+    parsed[1],
+    parsed[2]
+  ];
+  const upper = [
+    parsed[0],
+    parsed[1] + 1,
+    0
+  ];
+  return {
+    lower,
+    upper
+  };
+}
+function computeCaretBounds(value) {
+  const parsed = parseSemver(value);
+  const [major, minor, patch] = parsed;
+  const lower = [
+    major,
+    minor,
+    patch
+  ];
+  let upper;
+  upper = major > 0 ? [
+    major + 1,
+    0,
+    0
+  ] : minor > 0 ? [
+    0,
+    minor + 1,
+    0
+  ] : [
+    0,
+    0,
+    patch + 1
+  ];
+  return {
+    lower,
+    upper
+  };
+}
+function computeWildcardBounds(value) {
+  const text = String(value).trim().replace(/^[vV]/, "");
+  const cleanedText = text.replace(/\.\*$/, "").replace(/\*$/, "");
+  if (!cleanedText) throw new InconclusiveMatchError(`Invalid wildcard semver: ${value}`);
+  const parts = cleanedText.split(".");
+  const major = parseInt(parts[0], 10);
+  if (isNaN(major)) throw new InconclusiveMatchError(`Invalid wildcard semver: ${value}`);
+  let lower;
+  let upper;
+  if (1 === parts.length) {
+    lower = [
+      major,
+      0,
+      0
+    ];
+    upper = [
+      major + 1,
+      0,
+      0
+    ];
+  } else {
+    const minor = parseInt(parts[1], 10);
+    if (isNaN(minor)) throw new InconclusiveMatchError(`Invalid wildcard semver: ${value}`);
+    lower = [
+      major,
+      minor,
+      0
+    ];
+    upper = [
+      major,
+      minor + 1,
+      0
+    ];
+  }
+  return {
+    lower,
+    upper
+  };
+}
 function convertToDateTime(value) {
   if (value instanceof Date) return value;
   if ("string" == typeof value || "number" == typeof value) {
@@ -2782,22 +2947,44 @@ class PostHogMemoryStorage {
 const MINIMUM_POLLING_INTERVAL = 100;
 const THIRTY_SECONDS = 3e4;
 const MAX_CACHE_SIZE = 5e4;
+const WAITUNTIL_DEBOUNCE_MS = 50;
+const WAITUNTIL_MAX_WAIT_MS = 500;
+const DEFAULT_NODE_HOST = "https://us.i.posthog.com";
+function normalizeApiKey(value) {
+  return "string" == typeof value ? value.trim() : "";
+}
+function normalizePersonalApiKey(value) {
+  const normalizedValue = "string" == typeof value ? value.trim() : "";
+  return normalizedValue || void 0;
+}
+function normalizeHost(value) {
+  const normalizedValue = "string" == typeof value ? value.trim() : "";
+  return normalizedValue || DEFAULT_NODE_HOST;
+}
 class PostHogBackendClient extends PostHogCoreStateless {
   constructor(apiKey, options = {}) {
-    super(apiKey, options), this._memoryStorage = new PostHogMemoryStorage();
-    this.options = options;
+    const normalizedApiKey = normalizeApiKey(apiKey);
+    const normalizedOptions = {
+      ...options,
+      host: normalizeHost(options.host),
+      personalApiKey: normalizePersonalApiKey(options.personalApiKey)
+    };
+    super(normalizedApiKey, normalizedOptions), this._memoryStorage = new PostHogMemoryStorage();
+    this.options = normalizedOptions;
     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;
+    this.options.featureFlagsPollingInterval = "number" == typeof normalizedOptions.featureFlagsPollingInterval ? Math.max(normalizedOptions.featureFlagsPollingInterval, MINIMUM_POLLING_INTERVAL) : THIRTY_SECONDS;
+    if ("number" == typeof normalizedOptions.waitUntilDebounceMs) this.options.waitUntilDebounceMs = Math.max(normalizedOptions.waitUntilDebounceMs, 0);
+    if ("number" == typeof normalizedOptions.waitUntilMaxWaitMs) this.options.waitUntilMaxWaitMs = Math.max(normalizedOptions.waitUntilMaxWaitMs, 0);
+    if (normalizedOptions.personalApiKey) {
+      if (normalizedOptions.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 !== normalizedOptions.enableLocalEvaluation;
       if (shouldEnableLocalEvaluation) this.featureFlagsPoller = new FeatureFlagsPoller({
         pollingInterval: this.options.featureFlagsPollingInterval,
-        personalApiKey: options.personalApiKey,
-        projectApiKey: apiKey,
-        timeout: options.requestTimeout ?? 1e4,
+        personalApiKey: normalizedOptions.personalApiKey,
+        projectApiKey: normalizedApiKey,
+        timeout: normalizedOptions.requestTimeout ?? 1e4,
         host: this.host,
-        fetch: options.fetch,
+        fetch: normalizedOptions.fetch,
         onError: (err) => {
           this._events.emit("error", err);
         },
@@ -2805,13 +2992,74 @@ class PostHogBackendClient extends PostHogCoreStateless {
           this._events.emit("localEvaluationFlagsLoaded", count);
         },
         customHeaders: this.getCustomHeaders(),
-        cacheProvider: options.flagDefinitionCacheProvider,
-        strictLocalEvaluation: options.strictLocalEvaluation
+        cacheProvider: normalizedOptions.flagDefinitionCacheProvider,
+        strictLocalEvaluation: normalizedOptions.strictLocalEvaluation
       });
     }
-    this.errorTracking = new ErrorTracking(this, options, this._logger);
+    this.errorTracking = new ErrorTracking(this, normalizedOptions, this._logger);
     this.distinctIdHasSentFlagCalls = {};
-    this.maxCacheSize = options.maxCacheSize || MAX_CACHE_SIZE;
+    this.maxCacheSize = normalizedOptions.maxCacheSize || MAX_CACHE_SIZE;
+  }
+  enqueue(type, message, options) {
+    super.enqueue(type, message, options);
+    this.scheduleDebouncedFlush();
+  }
+  async flush() {
+    const flushPromise = super.flush();
+    const waitUntil = this.options.waitUntil;
+    if (waitUntil && !this._waitUntilCycle) try {
+      waitUntil(flushPromise.catch(() => {
+      }));
+    } catch {
+    }
+    return flushPromise;
+  }
+  scheduleDebouncedFlush() {
+    const waitUntil = this.options.waitUntil;
+    if (!waitUntil) return;
+    if (this.disabled || this.optedOut) return;
+    if (!this._waitUntilCycle) {
+      let resolve;
+      const promise = new Promise((r) => {
+        resolve = r;
+      });
+      try {
+        waitUntil(promise);
+      } catch {
+        return;
+      }
+      this._waitUntilCycle = {
+        resolve,
+        startedAt: Date.now(),
+        timer: void 0
+      };
+    }
+    const elapsed = Date.now() - this._waitUntilCycle.startedAt;
+    const maxWaitMs = this.options.waitUntilMaxWaitMs ?? WAITUNTIL_MAX_WAIT_MS;
+    const flushNow = elapsed >= maxWaitMs;
+    if (void 0 !== this._waitUntilCycle.timer) clearTimeout(this._waitUntilCycle.timer);
+    if (flushNow) return void this.resolveWaitUntilFlush();
+    const debounceMs = this.options.waitUntilDebounceMs ?? WAITUNTIL_DEBOUNCE_MS;
+    this._waitUntilCycle.timer = safeSetTimeout(() => {
+      this.resolveWaitUntilFlush();
+    }, debounceMs);
+  }
+  _consumeWaitUntilCycle() {
+    const cycle = this._waitUntilCycle;
+    if (cycle) {
+      clearTimeout(cycle.timer);
+      this._waitUntilCycle = void 0;
+    }
+    return cycle?.resolve;
+  }
+  async resolveWaitUntilFlush() {
+    const resolve = this._consumeWaitUntilCycle();
+    try {
+      await super.flush();
+    } catch {
+    } finally {
+      resolve?.();
+    }
   }
   getPersistedProperty(key) {
     return this._memoryStorage.getProperty(key);
@@ -3028,8 +3276,12 @@ class PostHogBackendClient extends PostHogCoreStateless {
           locally_evaluated: flagWasLocallyEvaluated,
           [`$feature/${key}`]: response,
           $feature_flag_request_id: requestId,
-          $feature_flag_evaluated_at: evaluatedAt
+          $feature_flag_evaluated_at: flagWasLocallyEvaluated ? Date.now() : evaluatedAt
         };
+        if (flagWasLocallyEvaluated && this.featureFlagsPoller) {
+          const flagDefinitionsLoadedAt = this.featureFlagsPoller.getFlagDefinitionsLoadedAt();
+          if (void 0 !== flagDefinitionsLoadedAt) properties.$feature_flag_definitions_loaded_at = flagDefinitionsLoadedAt;
+        }
         if (featureFlagError) properties.$feature_flag_error = featureFlagError;
         this.capture({
           distinctId,
@@ -3212,9 +3464,14 @@ class PostHogBackendClient extends PostHogCoreStateless {
     this.context?.enter(data, options);
   }
   async _shutdown(shutdownTimeoutMs) {
-    this.featureFlagsPoller?.stopPoller(shutdownTimeoutMs);
+    const resolve = this._consumeWaitUntilCycle();
+    await this.featureFlagsPoller?.stopPoller(shutdownTimeoutMs);
     this.errorTracking.shutdown();
-    return super._shutdown(shutdownTimeoutMs);
+    try {
+      return await super._shutdown(shutdownTimeoutMs);
+    } finally {
+      resolve?.();
+    }
   }
   async _requestRemoteConfigPayload(flagKey) {
     if (!this.options.personalApiKey) return;
@@ -3331,7 +3588,7 @@ class PostHogBackendClient extends PostHogCoreStateless {
   async captureExceptionImmediate(error, distinctId, additionalProperties) {
     if (!ErrorTracking.isPreviouslyCapturedError(error)) {
       const syntheticException = new Error("PostHog syntheticException");
-      this.addPendingPromise(ErrorTracking.buildEventMessage(error, {
+      return this.addPendingPromise(ErrorTracking.buildEventMessage(error, {
         syntheticException
       }, distinctId, additionalProperties).then((msg) => this.captureImmediate(msg)));
     }
@@ -3484,7 +3741,8 @@ ErrorTracking.errorPropertiesBuilder = new ErrorPropertiesBuilder([
   new PrimitiveCoercer()
 ], createStackParser("node:javascript", nodeStackLineParser), [
   createModulerModifier(),
-  addSourceContext
+  addSourceContext,
+  createRelativePathModifier()
 ]);
 class PostHog extends PostHogBackendClient {
   getLibraryId() {
@@ -3815,30 +4073,30 @@ const shutdownSession = async (session2) => {
 };
 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 relative2 = path.relative(root, candidate);
+  return relative2 === "" || !relative2.startsWith("..") && !path.isAbsolute(relative2);
 };
 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/")) {
+  const relative2 = toPosixPath(path.relative(projectRoot, absolutePath));
+  if (relative2.startsWith("src/api/") || relative2.includes("/src/api/")) {
     return "api";
   }
-  if (relative.startsWith("src/worker/") || relative.includes("/src/worker/")) {
+  if (relative2.startsWith("src/worker/") || relative2.includes("/src/worker/")) {
     return "worker";
   }
-  if (relative.startsWith("src/server/") || relative.includes("/src/server/")) {
+  if (relative2.startsWith("src/server/") || relative2.includes("/src/server/")) {
     return "ssr";
   }
-  if (relative.startsWith("build/dist/api/") || relative.includes("/build/dist/api/")) {
+  if (relative2.startsWith("build/dist/api/") || relative2.includes("/build/dist/api/")) {
     return "api";
   }
-  if (relative.startsWith("build/dist/worker/") || relative.includes("/build/dist/worker/")) {
+  if (relative2.startsWith("build/dist/worker/") || relative2.includes("/build/dist/worker/")) {
     return "worker";
   }
-  if (relative.startsWith("build/dist/ssr/") || relative.includes("/build/dist/ssr/")) {
+  if (relative2.startsWith("build/dist/ssr/") || relative2.includes("/build/dist/ssr/")) {
     return "ssr";
   }
   return "ssr";
@@ -3981,26 +4239,17 @@ 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`;
+const getMongoSessionUrl = (serverEnv) => {
+  const appName = serverEnv.APP_NAME?.trim();
+  if (!appName) {
+    throw new Error("Missing APP_NAME (required to build MongoDB session store DB name)");
   }
-  return void 0;
+  return getMongoUrl(serverEnv, {
+    dbName: `${appName}-sessions`
+  });
 };
 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)");
-  }
+  const mongoUrl = getMongoSessionUrl(serverEnv);
   console.log("Using MongoDB session store");
   const client2 = await MongoClient.connect(mongoUrl, {
     family: 4,