@swmansion/argent 0.12.1 → 0.13.1-next.0

package/dist/cli-cmds.mjs

@@ -171,12 +171,13 @@ import * as fs from "node:fs";
 import * as path from "node:path";
 import * as readline from "node:readline";
 import { homedir } from "node:os";
-import { spawn } from "node:child_process";
+import { spawn, execFileSync } from "node:child_process";
 import { randomBytes } from "node:crypto";
 import { mkdir, writeFile, readFile, unlink, rename, chmod } from "node:fs/promises";
 var STATE_DIR = path.join(homedir(), ".argent");
 var STATE_FILE = path.join(STATE_DIR, "tool-server.json");
 var LOG_FILE = path.join(STATE_DIR, "tool-server.log");
+var LOCK_FILE = path.join(STATE_DIR, "tool-server.lock");
 var AUTH_TOKEN_BYTES = 32;
 var AUTH_TOKEN_ENV = "ARGENT_AUTH_TOKEN";
 var AUTOSPAWN_IDLE_TIMEOUT_MINUTES = 30;
@@ -249,6 +250,8 @@ async function isToolsServerHealthy(port, host = "127.0.0.1", timeoutMs = 2e3, t
       signal: controller.signal,
       headers: authHeaders(token)
     });
+    await res.body?.cancel().catch(() => {
+    });
     return res.ok;
   } catch {
     return false;
@@ -256,6 +259,17 @@ async function isToolsServerHealthy(port, host = "127.0.0.1", timeoutMs = 2e3, t
     clearTimeout(timer);
   }
 }
+var SPAWN_READY_TIMEOUT_MS = 15e3;
+function killSpawnedChild(child, pid) {
+  try {
+    process.kill(-pid, "SIGKILL");
+  } catch {
+    try {
+      child.kill("SIGKILL");
+    } catch {
+    }
+  }
+}
 function spawnToolsServer(paths, port, options = {}) {
   return new Promise((resolve3, reject) => {
     let logFd;
@@ -282,6 +296,10 @@ function spawnToolsServer(paths, port, options = {}) {
       settled = true;
       fn();
     };
+    const rejectAndKill = (err) => settle(() => {
+      killSpawnedChild(child, pid);
+      reject(err);
+    });
     const rl = readline.createInterface({ input: child.stdout });
     rl.on("line", (line) => {
       const match = line.match(/Tools server listening on http:\/\/.+:(\d+)/);
@@ -294,7 +312,7 @@ function spawnToolsServer(paths, port, options = {}) {
     });
     child.on("error", (err) => {
       rl.close();
-      settle(() => reject(err));
+      rejectAndKill(err);
     });
     child.on("exit", (code) => {
       rl.close();
@@ -302,8 +320,8 @@ function spawnToolsServer(paths, port, options = {}) {
     });
     const timer = setTimeout(() => {
       rl.close();
-      settle(() => reject(new Error("Timed out waiting for tools server to become ready")));
-    }, 15e3);
+      rejectAndKill(new Error("Timed out waiting for tools server to become ready"));
+    }, options.readyTimeoutMs ?? SPAWN_READY_TIMEOUT_MS);
     rl.on("close", () => clearTimeout(timer));
   });
 }
@@ -359,63 +377,141 @@ async function waitForExit(pid, timeoutMs) {
   }
   return !isProcessAlive(pid);
 }
+async function terminatePid(pid, stillOurs) {
+  if (!isProcessAlive(pid)) return;
+  if (stillOurs && !stillOurs()) return;
+  try {
+    process.kill(pid, "SIGTERM");
+  } catch {
+    return;
+  }
+  if (await waitForExit(pid, SIGTERM_GRACE_MS)) return;
+  if (stillOurs && !(isProcessAlive(pid) && stillOurs())) return;
+  try {
+    process.kill(pid, "SIGKILL");
+  } catch {
+    return;
+  }
+  await waitForExit(pid, SIGKILL_GRACE_MS);
+}
 async function killToolServer() {
   const state2 = await readState();
   if (!state2) return;
-  let exited = !isProcessAlive(state2.pid);
-  if (!exited) {
+  await terminatePid(state2.pid);
+  await clearState();
+}
+function processCommandMatches(pid, marker) {
+  if (!marker) return false;
+  try {
+    const cmd = execFileSync("ps", ["-p", String(pid), "-o", "command="], {
+      encoding: "utf8",
+      timeout: 2e3,
+      stdio: ["ignore", "pipe", "ignore"]
+    }).trim();
+    if (!cmd) return false;
+    const argv = cmd.split(/\s+/);
+    return argv.includes(marker) && argv.includes("start");
+  } catch {
+    return false;
+  }
+}
+var LOCK_WAIT_TIMEOUT_MS = 3e4;
+var LOCK_STALE_MS = 45e3;
+var LOCK_POLL_MS = 100;
+function spawnLockIsStale() {
+  try {
+    const { pid, ts } = JSON.parse(fs.readFileSync(LOCK_FILE, "utf8"));
+    if (typeof pid === "number" && pid > 0 && !isProcessAlive(pid)) return true;
+    if (typeof ts === "number" && Date.now() - ts > LOCK_STALE_MS) return true;
+    return false;
+  } catch {
     try {
-      process.kill(state2.pid, "SIGTERM");
+      return Date.now() - fs.statSync(LOCK_FILE).mtimeMs > LOCK_STALE_MS;
     } catch {
-      exited = true;
+      return true;
     }
   }
-  if (!exited) {
-    exited = await waitForExit(state2.pid, SIGTERM_GRACE_MS);
+}
+async function acquireSpawnLock() {
+  try {
+    fs.mkdirSync(STATE_DIR, { recursive: true });
+  } catch {
+    return null;
   }
-  if (!exited) {
+  const nonce = randomBytes(8).toString("hex");
+  const deadline = Date.now() + LOCK_WAIT_TIMEOUT_MS;
+  for (; ; ) {
     try {
-      process.kill(state2.pid, "SIGKILL");
-    } catch {
-      exited = true;
-    }
-    if (!exited) {
-      await waitForExit(state2.pid, SIGKILL_GRACE_MS);
+      const fd = fs.openSync(LOCK_FILE, "wx");
+      try {
+        fs.writeSync(fd, JSON.stringify({ pid: process.pid, nonce, ts: Date.now() }));
+      } finally {
+        fs.closeSync(fd);
+      }
+      let released = false;
+      return {
+        release: () => {
+          if (released) return;
+          released = true;
+          try {
+            const cur = JSON.parse(fs.readFileSync(LOCK_FILE, "utf8"));
+            if (cur.pid === process.pid && cur.nonce === nonce) fs.unlinkSync(LOCK_FILE);
+          } catch {
+          }
+        }
+      };
+    } catch (err) {
+      if (err.code !== "EEXIST") return null;
+      if (spawnLockIsStale()) {
+        try {
+          fs.unlinkSync(LOCK_FILE);
+        } catch {
+        }
+        if (!fs.existsSync(LOCK_FILE)) continue;
+      }
+      if (Date.now() >= deadline) return null;
+      await new Promise((r2) => setTimeout(r2, LOCK_POLL_MS));
     }
   }
-  await clearState();
+}
+async function reusableHandle(state2) {
+  if (!state2 || !isProcessAlive(state2.pid)) return null;
+  const host = state2.host ?? "127.0.0.1";
+  const healthy = await isToolsServerHealthy(state2.port, host, 2e3, state2.token);
+  if (!healthy) return null;
+  return { url: formatUrl(healthCheckHost(host), state2.port), token: state2.token ?? "" };
 }
 async function ensureToolsServer(paths) {
-  const state2 = await readState();
-  if (state2) {
-    const alive = isProcessAlive(state2.pid);
-    if (alive) {
-      const host = state2.host ?? "127.0.0.1";
-      const healthy = await isToolsServerHealthy(state2.port, host, 2e3, state2.token);
-      if (healthy) {
-        return {
-          url: formatUrl(healthCheckHost(host), state2.port),
-          token: state2.token ?? ""
-        };
-      }
+  const fast = await reusableHandle(await readState());
+  if (fast) return fast;
+  const lock = await acquireSpawnLock();
+  try {
+    const state2 = await readState();
+    const reuse = await reusableHandle(state2);
+    if (reuse) return reuse;
+    if (state2 && state2.managed === "autospawn" && isProcessAlive(state2.pid) && processCommandMatches(state2.pid, state2.bundlePath)) {
+      await terminatePid(state2.pid, () => processCommandMatches(state2.pid, state2.bundlePath));
     }
     await clearState();
+    const token = generateToken();
+    const port = await findFreePort();
+    const { port: actualPort, pid } = await spawnToolsServer(paths, port, {
+      token,
+      idleTimeoutMinutes: AUTOSPAWN_IDLE_TIMEOUT_MINUTES
+    });
+    await writeState({
+      port: actualPort,
+      pid,
+      startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      bundlePath: paths.bundlePath,
+      host: "127.0.0.1",
+      token,
+      managed: "autospawn"
+    });
+    return { url: formatUrl("127.0.0.1", actualPort), token };
+  } finally {
+    lock?.release();
   }
-  const token = generateToken();
-  const port = await findFreePort();
-  const { port: actualPort, pid } = await spawnToolsServer(paths, port, {
-    token,
-    idleTimeoutMinutes: AUTOSPAWN_IDLE_TIMEOUT_MINUTES
-  });
-  await writeState({
-    port: actualPort,
-    pid,
-    startedAt: (/* @__PURE__ */ new Date()).toISOString(),
-    bundlePath: paths.bundlePath,
-    host: "127.0.0.1",
-    token
-  });
-  return { url: formatUrl("127.0.0.1", actualPort), token };
 }
 
 // ../argent-tools-client/src/link-config.ts
@@ -933,6 +1029,7 @@ var types_PostHogPersistedProperty = /* @__PURE__ */ (function(PostHogPersistedP
   PostHogPersistedProperty["InstalledAppBuild"] = "installed_app_build";
   PostHogPersistedProperty["InstalledAppVersion"] = "installed_app_version";
   PostHogPersistedProperty["SessionReplay"] = "session_replay";
+  PostHogPersistedProperty["SessionReplayEventTriggerActivatedSession"] = "session_replay_event_trigger_activated_session";
   PostHogPersistedProperty["SurveyLastSeenDate"] = "survey_last_seen_date";
   PostHogPersistedProperty["SurveysSeen"] = "surveys_seen";
   PostHogPersistedProperty["Surveys"] = "surveys";
@@ -1461,6 +1558,14 @@ var GENERIC_MOBILE = GENERIC + " " + MOBILE.toLowerCase();
 var GENERIC_TABLET = GENERIC + " " + TABLET.toLowerCase();
 var KONQUEROR = "Konqueror";
 var OCULUS_BROWSER = "Oculus Browser";
+var VIVALDI = "Vivaldi";
+var YANDEX = "Yandex";
+var WHALE = "Whale";
+var DUCKDUCKGO = "DuckDuckGo";
+var PALE_MOON = "Pale Moon";
+var WATERFOX = "Waterfox";
+var BRAVE = "Brave";
+var GOOGLE_SEARCH_APP = "Google Search App";
 var BROWSER_VERSION_REGEX_SUFFIX = "(\\d+(\\.\\d+)?)";
 var DEFAULT_BROWSER_VERSION_REGEX = new RegExp("Version/" + BROWSER_VERSION_REGEX_SUFFIX);
 var XBOX_REGEX = new RegExp(XBOX, "i");
@@ -1527,6 +1632,30 @@ var versionRegexes = {
   [OCULUS_BROWSER]: [
     new RegExp("OculusBrowser\\/" + BROWSER_VERSION_REGEX_SUFFIX)
   ],
+  [VIVALDI]: [
+    new RegExp(VIVALDI + "\\/" + BROWSER_VERSION_REGEX_SUFFIX)
+  ],
+  [YANDEX]: [
+    new RegExp("YaBrowser\\/" + BROWSER_VERSION_REGEX_SUFFIX)
+  ],
+  [WHALE]: [
+    new RegExp(WHALE + "\\/" + BROWSER_VERSION_REGEX_SUFFIX)
+  ],
+  [BRAVE]: [
+    new RegExp(BRAVE + "\\/" + BROWSER_VERSION_REGEX_SUFFIX)
+  ],
+  [DUCKDUCKGO]: [
+    new RegExp("(DuckDuckGo|Ddg)\\/" + BROWSER_VERSION_REGEX_SUFFIX)
+  ],
+  [PALE_MOON]: [
+    new RegExp("PaleMoon\\/" + BROWSER_VERSION_REGEX_SUFFIX)
+  ],
+  [WATERFOX]: [
+    new RegExp(WATERFOX + "\\/" + BROWSER_VERSION_REGEX_SUFFIX)
+  ],
+  [GOOGLE_SEARCH_APP]: [
+    new RegExp("GSA\\/" + BROWSER_VERSION_REGEX_SUFFIX)
+  ],
   [INTERNET_EXPLORER]: [
     new RegExp("(rv:|MSIE )" + BROWSER_VERSION_REGEX_SUFFIX)
   ],
@@ -1684,6 +1813,13 @@ var osMatchers = [
 
 // ../../node_modules/@posthog/core/dist/utils/index.mjs
 var STRING_FORMAT = "utf8";
+var UUID_REGEX = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+function isValidUUID(value) {
+  return "string" == typeof value && UUID_REGEX.test(value);
+}
+function getEventUuid(uuid, generateUuid) {
+  return isValidUUID(uuid) ? uuid : generateUuid();
+}
 function removeTrailingSlash(url) {
   return url?.replace(/\/+$/, "");
 }
@@ -1768,1515 +1904,1547 @@ var SimpleEventEmitter = class {
   }
 };
 
-// ../../node_modules/@posthog/core/dist/posthog-core-stateless.mjs
-var PostHogFetchHttpError = class 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();
-  }
-};
-var PostHogFetchNetworkError = class 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 text2 = "";
-    try {
-      text2 = await err.text;
-    } catch {
+// ../../node_modules/@posthog/core/dist/error-tracking/index.mjs
+var error_tracking_exports = {};
+__export(error_tracking_exports, {
+  DEFAULT_EXCEPTION_STEPS_CONFIG: () => DEFAULT_EXCEPTION_STEPS_CONFIG,
+  DOMExceptionCoercer: () => DOMExceptionCoercer,
+  EXCEPTION_STEP_INTERNAL_FIELDS: () => EXCEPTION_STEP_INTERNAL_FIELDS,
+  ErrorCoercer: () => ErrorCoercer,
+  ErrorEventCoercer: () => ErrorEventCoercer,
+  ErrorPropertiesBuilder: () => ErrorPropertiesBuilder,
+  EventCoercer: () => EventCoercer,
+  ExceptionStepsBuffer: () => ExceptionStepsBuffer,
+  ObjectCoercer: () => ObjectCoercer,
+  PrimitiveCoercer: () => PrimitiveCoercer,
+  PromiseRejectionEventCoercer: () => PromiseRejectionEventCoercer,
+  ReduceableCache: () => ReduceableCache,
+  StringCoercer: () => StringCoercer,
+  chromeStackLineParser: () => chromeStackLineParser,
+  createDefaultStackParser: () => createDefaultStackParser,
+  createStackParser: () => createStackParser,
+  geckoStackLineParser: () => geckoStackLineParser,
+  getUtf8ByteLength: () => getUtf8ByteLength,
+  nodeStackLineParser: () => nodeStackLineParser,
+  opera10StackLineParser: () => opera10StackLineParser,
+  opera11StackLineParser: () => opera11StackLineParser,
+  resolveExceptionStepsConfig: () => resolveExceptionStepsConfig,
+  reverseAndStripFrames: () => reverseAndStripFrames,
+  stripReservedExceptionStepFields: () => stripReservedExceptionStepFields,
+  winjsStackLineParser: () => winjsStackLineParser
+});
+
+// ../../node_modules/@posthog/core/dist/error-tracking/chunk-ids.mjs
+var parsedStackResults;
+var lastKeysCount;
+var 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 i2 = parsedStack.length - 1; i2 >= 0; i2--) {
+        const stackFrame = parsedStack[i2];
+        const filename = stackFrame?.filename;
+        const chunkId = chunkIdMap[stackKey];
+        if (filename && chunkId) {
+          acc[filename] = chunkId;
+          parsedStackResults[stackKey] = [
+            filename,
+            chunkId
+          ];
+          break;
+        }
+      }
     }
-    console.error(`Error while flushing PostHog: message=${err.message}, response body=${text2}`, 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;
+    return acc;
+  }, {});
+  return cachedFilenameChunkIds;
 }
-var PostHogCoreStateless = class {
-  constructor(apiKey, options = {}) {
-    this.flushPromise = null;
-    this.shutdownPromise = null;
-    this.promiseQueue = new PromiseQueue();
-    this._events = new SimpleEventEmitter();
-    this._isInitialized = false;
-    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);
-    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) || missingApiKey;
-    this.historicalMigration = options?.historicalMigration ?? false;
-    this._initPromise = Promise.resolve();
-    this._isInitialized = true;
-    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);
+
+// ../../node_modules/@posthog/core/dist/error-tracking/error-properties-builder.mjs
+var MAX_CAUSE_RECURSION = 4;
+var ErrorPropertiesBuilder = class {
+  constructor(coercers, stackParser, modifiers = []) {
+    this.coercers = coercers;
+    this.stackParser = stackParser;
+    this.modifiers = modifiers;
   }
-  logMsgIfDebug(fn) {
-    if (this.isDebug) fn();
+  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(hint);
+    const exceptionWithStack = this.parseStacktrace(exceptionWithCause, parsingContext);
+    const exceptionList = this.convertToExceptionList(exceptionWithStack, mechanism);
+    return {
+      $exception_list: exceptionList,
+      $exception_level: "error"
+    };
   }
-  wrap(fn) {
-    if (this.disabled) return void this._logger.warn("The client is disabled");
-    if (this._isInitialized) return fn();
-    this._initPromise.then(() => fn());
+  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;
   }
-  getCommonEventProperties() {
+  coerceFallback(ctx) {
     return {
-      $lib: this.getLibraryId(),
-      $lib_version: this.getLibraryVersion()
+      type: "Error",
+      value: "Unknown error",
+      stack: ctx.syntheticException?.stack,
+      synthetic: true
     };
   }
-  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) {
+  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 ? ctx.skipFirstLines : 0), ctx.chunkIdMap);
     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
-      })
+      ...err,
+      cause,
+      stack
     };
-    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);
+  applyChunkIds(frames, chunkIdMap) {
+    return frames.map((frame) => {
+      if (frame.filename && chunkIdMap) frame.chunk_id = chunkIdMap[frame.filename];
+      return frame;
     });
   }
-  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);
+  applyCoercers(input, ctx) {
+    for (const adapter of this.coercers) if (adapter.match(input)) return adapter.coerce(input, ctx);
+    return this.coerceFallback(ctx);
   }
-  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 applyModifiers(frames) {
+    let newFrames = frames;
+    for (const modifier of this.modifiers) newFrames = await modifier(newFrames);
+    return newFrames;
   }
-  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"
+  convertToExceptionList(exceptionWithStack, mechanism) {
+    const currentException = {
+      type: exceptionWithStack.type,
+      value: exceptionWithStack.value,
+      mechanism: {
+        type: mechanism.type ?? "generic",
+        handled: mechanism.handled ?? true,
+        synthetic: exceptionWithStack.synthetic ?? false
       }
     };
-    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 = false) {
-    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 (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",
-      headers: {
-        ...this.getCustomHeaders(),
-        "Content-Type": "application/json"
-      },
-      body: JSON.stringify(requestData)
+    if (exceptionWithStack.stack) currentException.stacktrace = {
+      type: "raw",
+      frames: exceptionWithStack.stack
     };
-    this._logger.info("Flags URL", url);
-    return this.fetchWithRetry(url, fetchOptions, {
-      retryCount: 0
-    }, this.featureFlagsRequestTimeoutMs).then((response) => response.json()).then((response) => ({
-      success: true,
-      response: normalizeFlagsResponse(response)
-    })).catch((error) => {
-      this._events.emit("error", error);
-      return {
-        success: false,
-        error: this.categorizeRequestError(error)
-      };
-    });
+    const exceptionList = [
+      currentException
+    ];
+    if (null != exceptionWithStack.cause) exceptionList.push(...this.convertToExceptionList(exceptionWithStack.cause, {
+      ...mechanism,
+      handled: true
+    }));
+    return exceptionList;
   }
-  categorizeRequestError(error) {
-    if (error instanceof PostHogFetchHttpError) return {
-      type: "api_error",
-      statusCode: error.status
-    };
-    if (error instanceof PostHogFetchNetworkError) {
-      const cause = error.error;
-      if (cause instanceof Error && ("AbortError" === cause.name || "TimeoutError" === cause.name)) return {
-        type: "timeout"
-      };
-      return {
-        type: "connection_error"
-      };
-    }
-    return {
-      type: "unknown_error"
+  buildParsingContext(hint) {
+    const context = {
+      chunkIdMap: getFilenameToChunkIdMap(this.stackParser),
+      skipFirstLines: hint.skipFirstLines ?? 1
     };
+    return context;
   }
-  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
+  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);
+      }
     };
-    let response = getFeatureFlagValue(flagDetailResponse.response);
-    if (void 0 === response) response = false;
-    return {
-      response,
-      requestId: flagDetailResponse.requestId
+    const context = {
+      ...hint,
+      syntheticException: 0 == depth ? hint.syntheticException : void 0,
+      mechanism,
+      apply: (input) => coerce(input, depth),
+      next: (input) => coerce(input, depth + 1)
     };
+    return context;
   }
-  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];
+};
+
+// ../../node_modules/@posthog/core/dist/error-tracking/parsers/base.mjs
+var UNKNOWN_FUNCTION = "?";
+function createFrame(platform, filename, func, lineno, colno) {
+  const frame = {
+    platform,
+    filename,
+    function: "<anonymous>" === func ? UNKNOWN_FUNCTION : func,
+    in_app: true
+  };
+  if (!isUndefined(lineno)) frame.lineno = lineno;
+  if (!isUndefined(colno)) frame.colno = colno;
+  return frame;
+}
+
+// ../../node_modules/@posthog/core/dist/error-tracking/parsers/safari.mjs
+var extractSafariExtensionDetails = (func, filename) => {
+  const isSafariExtension = -1 !== func.indexOf("safari-extension");
+  const isSafariWebExtension = -1 !== func.indexOf("safari-web-extension");
+  return isSafariExtension || isSafariWebExtension ? [
+    -1 !== func.indexOf("@") ? func.split("@")[0] : UNKNOWN_FUNCTION,
+    isSafariExtension ? `safari-extension:${filename}` : `safari-web-extension:${filename}`
+  ] : [
+    func,
+    filename
+  ];
+};
+
+// ../../node_modules/@posthog/core/dist/error-tracking/parsers/chrome.mjs
+var chromeRegexNoFnName = /^\s*at (\S+?)(?::(\d+))(?::(\d+))\s*$/i;
+var chromeRegex = /^\s*at (?:(.+?\)(?: \[.+\])?|.*?) ?\((?:address at )?)?(?:async )?((?:<anonymous>|[-a-z]+:|.*bundle|\/)?.*?)(?::(\d+))?(?::(\d+))?\)?\s*$/i;
+var chromeEvalRegex = /\((\S*)(?::(\d+))(?::(\d+))\)/;
+var chromeStackLineParser = (line, platform) => {
+  const noFnParts = chromeRegexNoFnName.exec(line);
+  if (noFnParts) {
+    const [, filename, line2, col] = noFnParts;
+    return createFrame(platform, filename, UNKNOWN_FUNCTION, +line2, +col);
+  }
+  const parts = chromeRegex.exec(line);
+  if (parts) {
+    const isEval = parts[2] && 0 === parts[2].indexOf("eval");
+    if (isEval) {
+      const subMatch = chromeEvalRegex.exec(parts[2]);
+      if (subMatch) {
+        parts[2] = subMatch[1];
+        parts[3] = subMatch[2];
+        parts[4] = subMatch[3];
+      }
+    }
+    const [func, filename] = extractSafariExtensionDetails(parts[1] || UNKNOWN_FUNCTION, parts[2]);
+    return createFrame(platform, filename, func, parts[3] ? +parts[3] : void 0, parts[4] ? +parts[4] : void 0);
+  }
+};
+
+// ../../node_modules/@posthog/core/dist/error-tracking/parsers/gecko.mjs
+var geckoREgex = /^\s*(.*?)(?:\((.*?)\))?(?:^|@)?((?:[-a-z]+)?:\/.*?|\[native code\]|[^@]*(?:bundle|\d+\.js)|\/[\w\-. /=]+)(?::(\d+))?(?::(\d+))?\s*$/i;
+var geckoEvalRegex = /(\S+) line (\d+)(?: > eval line \d+)* > eval/i;
+var geckoStackLineParser = (line, platform) => {
+  const parts = geckoREgex.exec(line);
+  if (parts) {
+    const isEval = parts[3] && parts[3].indexOf(" > eval") > -1;
+    if (isEval) {
+      const subMatch = geckoEvalRegex.exec(parts[3]);
+      if (subMatch) {
+        parts[1] = parts[1] || "eval";
+        parts[3] = subMatch[1];
+        parts[4] = subMatch[2];
+        parts[5] = "";
+      }
+    }
+    let filename = parts[3];
+    let func = parts[1] || UNKNOWN_FUNCTION;
+    [func, filename] = extractSafariExtensionDetails(func, filename);
+    return createFrame(platform, filename, func, parts[4] ? +parts[4] : void 0, parts[5] ? +parts[5] : void 0);
+  }
+};
+
+// ../../node_modules/@posthog/core/dist/error-tracking/parsers/winjs.mjs
+var winjsRegex = /^\s*at (?:((?:\[object object\])?.+) )?\(?((?:[-a-z]+):.*?):(\d+)(?::(\d+))?\)?\s*$/i;
+var winjsStackLineParser = (line, platform) => {
+  const parts = winjsRegex.exec(line);
+  return parts ? createFrame(platform, parts[2], parts[1] || UNKNOWN_FUNCTION, +parts[3], parts[4] ? +parts[4] : void 0) : void 0;
+};
+
+// ../../node_modules/@posthog/core/dist/error-tracking/parsers/opera.mjs
+var opera10Regex = / line (\d+).*script (?:in )?(\S+)(?:: in function (\S+))?$/i;
+var opera10StackLineParser = (line, platform) => {
+  const parts = opera10Regex.exec(line);
+  return parts ? createFrame(platform, parts[2], parts[3] || UNKNOWN_FUNCTION, +parts[1]) : void 0;
+};
+var opera11Regex = / line (\d+), column (\d+)\s*(?:in (?:<anonymous function: ([^>]+)>|([^)]+))\(.*\))? in (.*):\s*$/i;
+var opera11StackLineParser = (line, platform) => {
+  const parts = opera11Regex.exec(line);
+  return parts ? createFrame(platform, parts[5], parts[3] || parts[4] || UNKNOWN_FUNCTION, +parts[1], +parts[2]) : void 0;
+};
+
+// ../../node_modules/@posthog/core/dist/error-tracking/parsers/node.mjs
+var FILENAME_MATCH = /^\s*[-]{4,}$/;
+var FULL_MATCH = /at (?:async )?(?:(.+?)\s+\()?(?:(.+):(\d+):(\d+)?|([^)]+))\)?/;
+var 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 {
-      response: flagDetail,
-      requestId: flagsResponse.requestId,
-      evaluatedAt: flagsResponse.evaluatedAt
+      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
     };
   }
-  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;
+  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;
+}
+
+// ../../node_modules/@posthog/core/dist/error-tracking/parsers/index.mjs
+var WEBPACK_ERROR_REGEXP = /\(error: (.*)\)/;
+var 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 createDefaultStackParser() {
+  return createStackParser("web:javascript", chromeStackLineParser, geckoStackLineParser);
+}
+function createStackParser(platform, ...parsers) {
+  return (stack, skipFirstLines = 0) => {
+    const frames = [];
+    const lines = stack.split("\n");
+    for (let i2 = skipFirstLines; i2 < lines.length; i2++) {
+      const line = lines[i2];
+      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);
+  };
+}
+
+// ../../node_modules/@posthog/core/dist/error-tracking/coercers/dom-exception-coercer.mjs
+var DOMExceptionCoercer = class {
+  match(err) {
+    return this.isDOMException(err) || this.isDOMError(err);
   }
-  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;
+  coerce(err, ctx) {
+    const hasStack = isString(err.stack);
+    return {
+      type: this.getType(err),
+      value: this.getValue(err),
+      stack: hasStack ? err.stack : void 0,
+      cause: err.cause ? ctx.next(err.cause) : void 0,
+      synthetic: false
+    };
   }
-  async getFeatureFlagsStateless(distinctId, groups = {}, personProperties = {}, groupProperties = {}, disableGeoip, flagKeysToEvaluate) {
-    await this._initPromise;
-    return await this.getFeatureFlagsAndPayloadsStateless(distinctId, groups, personProperties, groupProperties, disableGeoip, flagKeysToEvaluate);
+  getType(candidate) {
+    return this.isDOMError(candidate) ? "DOMError" : "DOMException";
   }
-  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
+  getValue(err) {
+    const name = err.name || (this.isDOMError(err) ? "DOMError" : "DOMException");
+    const message = err.message ? `${name}: ${err.message}` : name;
+    return message;
+  }
+  isDOMException(err) {
+    return isBuiltin(err, "DOMException");
+  }
+  isDOMError(err) {
+    return isBuiltin(err, "DOMError");
+  }
+};
+
+// ../../node_modules/@posthog/core/dist/error-tracking/coercers/error-coercer.mjs
+var ErrorCoercer = class {
+  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;
+  }
+};
+
+// ../../node_modules/@posthog/core/dist/error-tracking/coercers/error-event-coercer.mjs
+var ErrorEventCoercer = class {
+  constructor() {
+  }
+  match(err) {
+    return isErrorEvent(err) && void 0 != err.error;
+  }
+  coerce(err, ctx) {
+    const exceptionLike = ctx.apply(err.error);
+    if (!exceptionLike) return {
+      type: "ErrorEvent",
+      value: err.message,
+      stack: ctx.syntheticException?.stack,
+      synthetic: true
     };
+    return exceptionLike;
+  }
+};
+
+// ../../node_modules/@posthog/core/dist/error-tracking/coercers/string-coercer.mjs
+var ERROR_TYPES_PATTERN = /^(?:[Uu]ncaught (?:exception: )?)?(?:((?:Eval|Internal|Range|Reference|Syntax|Type|URI|)Error): )?(.*)$/i;
+var StringCoercer = class {
+  match(input) {
+    return "string" == typeof input;
+  }
+  coerce(input, ctx) {
+    const [type, value] = this.getInfos(input);
     return {
-      flags: featureFlagDetails.featureFlags,
-      payloads: featureFlagDetails.featureFlagPayloads,
-      requestId: featureFlagDetails.requestId
+      type: type ?? "Error",
+      value: value ?? input,
+      stack: ctx.syntheticException?.stack,
+      synthetic: true
     };
   }
-  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 result = await this.getFlags(distinctId, groups, personProperties, groupProperties, extraPayload);
-    if (!result.success) return;
-    const flagsResponse = result.response;
-    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
-      };
+  getInfos(candidate) {
+    let type = "Error";
+    let value = candidate;
+    const groups = candidate.match(ERROR_TYPES_PATTERN);
+    if (groups) {
+      type = groups[1];
+      value = groups[2];
     }
-    return flagsResponse;
+    return [
+      type,
+      value
+    ];
   }
-  async getSurveysStateless() {
-    await this._initPromise;
-    if (this.disabled) return [];
-    if (true === this.disableSurveys) {
-      this._logger.info("Loading surveys is disabled.");
-      return [];
+};
+
+// ../../node_modules/@posthog/core/dist/error-tracking/types.mjs
+var severityLevels = [
+  "fatal",
+  "error",
+  "warning",
+  "log",
+  "info",
+  "debug"
+];
+
+// ../../node_modules/@posthog/core/dist/error-tracking/coercers/utils.mjs
+function extractExceptionKeysForMessage(err, maxLength = 40) {
+  const keys = Object.keys(err);
+  keys.sort();
+  if (!keys.length) return "[object has no keys]";
+  for (let i2 = keys.length; i2 > 0; i2--) {
+    const serialized = keys.slice(0, i2).join(", ");
+    if (!(serialized.length > maxLength)) {
+      if (i2 === keys.length) return serialized;
+      return serialized.length <= maxLength ? serialized : `${serialized.slice(0, maxLength)}...`;
     }
-    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 || {};
+  return "";
+}
+
+// ../../node_modules/@posthog/core/dist/error-tracking/coercers/object-coercer.mjs
+var ObjectCoercer = class {
+  match(candidate) {
+    return "object" == typeof candidate && null !== candidate;
   }
-  set props(val) {
-    this._props = val;
+  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
+    };
   }
-  async register(properties) {
-    this.wrap(() => {
-      this.props = {
-        ...this.props,
-        ...properties
-      };
-      this.setPersistedProperty(types_PostHogPersistedProperty.Props, this.props);
-    });
+  getType(err) {
+    return isEvent(err) ? err.constructor.name : "Error";
   }
-  async unregister(property) {
-    this.wrap(() => {
-      delete this.props[property];
-      this.setPersistedProperty(types_PostHogPersistedProperty.Props, this.props);
-    });
+  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}`;
   }
-  processBeforeEnqueue(message) {
-    return message;
+  isSeverityLevel(x) {
+    return isString(x) && !isEmptyString(x) && severityLevels.indexOf(x) >= 0;
   }
-  async flushStorage() {
+  getErrorPropertyFromObject(obj) {
+    for (const prop in obj) if (Object.prototype.hasOwnProperty.call(obj, prop)) {
+      const value = obj[prop];
+      if (isError(value)) return value;
+    }
   }
-  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()");
-      let message = this.prepareMessage(type, _message, options);
-      message = this.processBeforeEnqueue(message);
-      if (null === message) return;
-      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);
-    });
+  getObjectClassName(obj) {
+    try {
+      const prototype = Object.getPrototypeOf(obj);
+      return prototype ? prototype.constructor.name : void 0;
+    } catch (e) {
+      return;
+    }
   }
-  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()");
-    let message = this.prepareMessage(type, _message, options);
-    message = this.processBeforeEnqueue(message);
-    if (null === message) return;
-    const data = {
-      api_key: this.apiKey,
-      batch: [
-        message
-      ],
-      sent_at: currentISOTime()
+};
+
+// ../../node_modules/@posthog/core/dist/error-tracking/coercers/event-coercer.mjs
+var EventCoercer = class {
+  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
     };
-    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
+  }
+};
+
+// ../../node_modules/@posthog/core/dist/error-tracking/coercers/primitive-coercer.mjs
+var PrimitiveCoercer = class {
+  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
     };
+  }
+};
+
+// ../../node_modules/@posthog/core/dist/error-tracking/coercers/promise-rejection-event.mjs
+var PromiseRejectionEventCoercer = class {
+  match(err) {
+    return isBuiltin(err, "PromiseRejectionEvent") || this.isCustomEventWrappingRejection(err);
+  }
+  isCustomEventWrappingRejection(err) {
+    if (!isEvent(err)) return false;
     try {
-      const response = await this.fetchWithRetry(url, fetchOptions);
-      await response.body?.cancel()?.catch(() => {
-      });
-    } catch (err) {
-      this._events.emit("error", err);
+      const detail = err.detail;
+      return null != detail && "object" == typeof detail && "reason" in detail;
+    } catch {
+      return false;
     }
   }
-  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()
+  coerce(err, ctx) {
+    const reason = this.getUnhandledRejectionReason(err);
+    if (isPrimitive(reason)) return {
+      type: "UnhandledRejection",
+      value: `Non-Error promise rejection captured with value: ${String(reason)}`,
+      stack: ctx.syntheticException?.stack,
+      synthetic: true
     };
-    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;
+    return ctx.apply(reason);
   }
-  clearFlushTimer() {
-    if (this._flushTimer) {
-      clearTimeout(this._flushTimer);
-      this._flushTimer = void 0;
+  getUnhandledRejectionReason(error) {
+    try {
+      if ("reason" in error) return error.reason;
+      if ("detail" in error && null != error.detail && "object" == typeof error.detail && "reason" in error.detail) return error.detail.reason;
+    } catch {
     }
+    return error;
   }
-  flushBackground() {
-    this.flush().catch(async (err) => {
-      await logFlushError(err);
-    });
-  }
-  async flush() {
-    if (this.disabled) return;
-    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;
+};
+
+// ../../node_modules/@posthog/core/dist/error-tracking/utils.mjs
+var ReduceableCache = class {
+  constructor(_maxSize) {
+    this._maxSize = _maxSize;
+    this._cache = /* @__PURE__ */ new Map();
   }
-  getCustomHeaders() {
-    const customUserAgent = this.getCustomUserAgent();
-    const headers = {};
-    if (customUserAgent && "" !== customUserAgent) headers["User-Agent"] = customUserAgent;
-    return headers;
+  get(key) {
+    const value = this._cache.get(key);
+    if (void 0 === value) return;
+    this._cache.delete(key);
+    this._cache.set(key, value);
+    return value;
   }
-  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 = async () => {
-        const refreshedQueue = this.getPersistedProperty(types_PostHogPersistedProperty.Queue) || [];
-        const newQueue = refreshedQueue.slice(batchItems.length);
-        this.setPersistedProperty(types_PostHogPersistedProperty.Queue, newQueue);
-        queue = newQueue;
-        await this.flushStorage();
-      };
-      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 {
-        const response = await this.fetchWithRetry(url, fetchOptions, retryOptions);
-        await response.body?.cancel()?.catch(() => {
-        });
-      } 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)) await persistQueueChange();
-        this._events.emit("error", err);
-        throw err;
-      }
-      await persistQueueChange();
-      sentMessages.push(...batchMessages);
-    }
-    this._events.emit("flush", sentMessages);
+  set(key, value) {
+    this._cache.set(key, value);
   }
-  async _sendLogsBatch(payload) {
-    if (this.disabled) return {
-      kind: "fatal",
-      error: new Error("The client is disabled")
-    };
-    const serialized = JSON.stringify(payload);
-    const url = `${this.host}/i/v1/logs?token=${encodeURIComponent(this.apiKey)}`;
-    const gzippedPayload = this.disableCompression ? null : await gzipCompress(serialized, this.isDebug);
-    const fetchOptions = {
-      method: "POST",
-      headers: {
-        ...this.getCustomHeaders(),
-        "Content-Type": "application/json",
-        ...null !== gzippedPayload && {
-          "Content-Encoding": "gzip"
-        }
-      },
-      body: gzippedPayload || serialized
-    };
-    try {
-      await this.fetchWithRetry(url, fetchOptions, {
-        retryCheck: (err) => {
-          if (isPostHogFetchContentTooLargeError(err)) return false;
-          return isPostHogFetchError(err);
-        }
-      });
-      return {
-        kind: "ok"
-      };
-    } catch (err) {
-      if (isPostHogFetchContentTooLargeError(err)) return {
-        kind: "too-large"
-      };
-      if (err instanceof PostHogFetchNetworkError) return {
-        kind: "retry-later",
-        error: err
-      };
-      return {
-        kind: "fatal",
-        error: err
-      };
+  reduce() {
+    while (this._cache.size >= this._maxSize) {
+      const value = this._cache.keys().next().value;
+      if (value) this._cache.delete(value);
     }
   }
-  async fetchWithRetry(url, options, retryOptions, requestTimeout) {
-    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;
-      }
+};
+
+// ../../node_modules/@posthog/core/dist/error-tracking/exception-steps.mjs
+var EXCEPTION_STEP_INTERNAL_FIELDS = {
+  MESSAGE: "$message",
+  TIMESTAMP: "$timestamp"
+};
+var RESERVED_EXCEPTION_STEP_KEYS = /* @__PURE__ */ new Set([
+  EXCEPTION_STEP_INTERNAL_FIELDS.MESSAGE,
+  EXCEPTION_STEP_INTERNAL_FIELDS.TIMESTAMP
+]);
+var DEFAULT_EXCEPTION_STEPS_CONFIG = {
+  enabled: true,
+  max_bytes: 32768
+};
+function resolveExceptionStepsConfig(config) {
+  if (!config) return {
+    ...DEFAULT_EXCEPTION_STEPS_CONFIG
+  };
+  return {
+    enabled: config.enabled ?? DEFAULT_EXCEPTION_STEPS_CONFIG.enabled,
+    max_bytes: normalizePositiveInteger(config.max_bytes, DEFAULT_EXCEPTION_STEPS_CONFIG.max_bytes)
+  };
+}
+function stripReservedExceptionStepFields(properties) {
+  if (!properties) return {
+    sanitizedProperties: {},
+    droppedKeys: []
+  };
+  const droppedKeys = [];
+  const sanitizedProperties = Object.keys(properties).reduce((acc, key) => {
+    if (RESERVED_EXCEPTION_STEP_KEYS.has(key)) {
+      droppedKeys.push(key);
+      return acc;
     }
-    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: 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);
-      return res;
-    }, {
-      ...this._retryOptions,
-      ...retryOptions
+    acc[key] = properties[key];
+    return acc;
+  }, {});
+  return {
+    sanitizedProperties,
+    droppedKeys
+  };
+}
+var ExceptionStepsBuffer = class {
+  constructor(config) {
+    this._entries = [];
+    this._totalBytes = 0;
+    this._config = resolveExceptionStepsConfig(config);
+  }
+  setConfig(config) {
+    this._config = resolveExceptionStepsConfig(config);
+    this._trimToMaxBytes();
+  }
+  add(step) {
+    const serialized = normalizeAndSerializeStep(step);
+    if (!serialized) return;
+    const bytes = getUtf8ByteLength(serialized.json);
+    if (bytes > this._config.max_bytes) return;
+    this._entries.push({
+      step: serialized.step,
+      bytes
     });
+    this._totalBytes += bytes;
+    this._trimToMaxBytes();
   }
-  async _shutdown(shutdownTimeoutMs = 3e4) {
-    await this._initPromise;
-    let hasTimedOut = false;
-    this.clearFlushTimer();
-    if (this.disabled) return;
-    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);
-      }
-    };
-    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);
+  getAttachable() {
+    return this._entries.map((e) => e.step);
+  }
+  clear() {
+    this._entries = [];
+    this._totalBytes = 0;
+  }
+  size() {
+    return this._entries.length;
+  }
+  _trimToMaxBytes() {
+    while (this._totalBytes > this._config.max_bytes && this._entries.length > 0) {
+      const evicted = this._entries.shift();
+      if (evicted) this._totalBytes -= evicted.bytes;
     }
   }
-  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;
+};
+function normalizePositiveInteger(input, fallback) {
+  if (!isNumber(input) || input === 1 / 0 || input === -1 / 0) return fallback;
+  const normalized = Math.floor(input);
+  if (normalized < 0) return fallback;
+  return normalized;
+}
+function normalizeAndSerializeStep(step) {
+  const json = safeStringify(step);
+  if (!json) return;
+  try {
+    const parsed = JSON.parse(json);
+    if (!isObject(parsed)) return;
+    const parsedStep = parsed;
+    const message = parsedStep[EXCEPTION_STEP_INTERNAL_FIELDS.MESSAGE];
+    const timestamp = parsedStep[EXCEPTION_STEP_INTERNAL_FIELDS.TIMESTAMP];
+    if (!isString(message) || 0 === message.trim().length) return;
+    if (!isString(timestamp) && !isNumber(timestamp)) return;
+    return {
+      step: parsedStep,
+      json
+    };
+  } catch {
+    return;
+  }
+}
+function safeStringify(value) {
+  const seen = /* @__PURE__ */ new WeakSet();
+  try {
+    return JSON.stringify(value, (_key, replacementValue) => {
+      if ("bigint" == typeof replacementValue) return replacementValue.toString();
+      if ("function" == typeof replacementValue || "symbol" == typeof replacementValue) return;
+      if (replacementValue instanceof Date) return replacementValue.toISOString();
+      if (replacementValue instanceof Error) return {
+        name: replacementValue.name,
+        message: replacementValue.message,
+        stack: replacementValue.stack
+      };
+      if (replacementValue && "object" == typeof replacementValue) {
+        if (seen.has(replacementValue)) return "[Circular]";
+        seen.add(replacementValue);
+      }
+      return replacementValue;
     });
-    return this.shutdownPromise;
+  } catch {
+    return;
   }
-};
-
-// ../../node_modules/@posthog/core/dist/error-tracking/index.mjs
-var error_tracking_exports = {};
-__export(error_tracking_exports, {
-  DEFAULT_EXCEPTION_STEPS_CONFIG: () => DEFAULT_EXCEPTION_STEPS_CONFIG,
-  DOMExceptionCoercer: () => DOMExceptionCoercer,
-  EXCEPTION_STEP_INTERNAL_FIELDS: () => EXCEPTION_STEP_INTERNAL_FIELDS,
-  ErrorCoercer: () => ErrorCoercer,
-  ErrorEventCoercer: () => ErrorEventCoercer,
-  ErrorPropertiesBuilder: () => ErrorPropertiesBuilder,
-  EventCoercer: () => EventCoercer,
-  ExceptionStepsBuffer: () => ExceptionStepsBuffer,
-  ObjectCoercer: () => ObjectCoercer,
-  PrimitiveCoercer: () => PrimitiveCoercer,
-  PromiseRejectionEventCoercer: () => PromiseRejectionEventCoercer,
-  ReduceableCache: () => ReduceableCache,
-  StringCoercer: () => StringCoercer,
-  chromeStackLineParser: () => chromeStackLineParser,
-  createDefaultStackParser: () => createDefaultStackParser,
-  createStackParser: () => createStackParser,
-  geckoStackLineParser: () => geckoStackLineParser,
-  getUtf8ByteLength: () => getUtf8ByteLength,
-  nodeStackLineParser: () => nodeStackLineParser,
-  opera10StackLineParser: () => opera10StackLineParser,
-  opera11StackLineParser: () => opera11StackLineParser,
-  resolveExceptionStepsConfig: () => resolveExceptionStepsConfig,
-  reverseAndStripFrames: () => reverseAndStripFrames,
-  stripReservedExceptionStepFields: () => stripReservedExceptionStepFields,
-  winjsStackLineParser: () => winjsStackLineParser
-});
+}
+function getUtf8ByteLength(value) {
+  if ("undefined" != typeof TextEncoder) return new TextEncoder().encode(value).length;
+  const encoded = encodeURIComponent(value);
+  let byteLength = 0;
+  for (let i2 = 0; i2 < encoded.length; i2++) if ("%" === encoded[i2]) {
+    byteLength += 1;
+    i2 += 2;
+  } else byteLength += 1;
+  return byteLength;
+}
 
-// ../../node_modules/@posthog/core/dist/error-tracking/chunk-ids.mjs
-var parsedStackResults;
-var lastKeysCount;
-var 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 i2 = parsedStack.length - 1; i2 >= 0; i2--) {
-        const stackFrame = parsedStack[i2];
-        const filename = stackFrame?.filename;
-        const chunkId = chunkIdMap[stackKey];
-        if (filename && chunkId) {
-          acc[filename] = chunkId;
-          parsedStackResults[stackKey] = [
-            filename,
-            chunkId
-          ];
-          break;
-        }
-      }
+// ../../node_modules/@posthog/core/dist/posthog-core-stateless.mjs
+var PostHogFetchHttpError = class 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();
+  }
+};
+var PostHogFetchNetworkError = class 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 text2 = "";
+    try {
+      text2 = await err.text;
+    } catch {
     }
-    return acc;
-  }, {});
-  return cachedFilenameChunkIds;
+    console.error(`Error while flushing PostHog: message=${err.message}, response body=${text2}`, err);
+  } else console.error("Error while flushing PostHog", err);
+  return Promise.resolve();
 }
-
-// ../../node_modules/@posthog/core/dist/error-tracking/error-properties-builder.mjs
-var MAX_CAUSE_RECURSION = 4;
-var ErrorPropertiesBuilder = class {
-  constructor(coercers, stackParser, modifiers = []) {
-    this.coercers = coercers;
-    this.stackParser = stackParser;
-    this.modifiers = modifiers;
+function isPostHogFetchError(err) {
+  return "object" == typeof err && (err instanceof PostHogFetchHttpError || isPostHogFetchNetworkError(err));
+}
+function isPostHogFetchNetworkError(err) {
+  return err instanceof PostHogFetchNetworkError;
+}
+function isPostHogFetchContentTooLargeError(err) {
+  return "object" == typeof err && err instanceof PostHogFetchHttpError && 413 === err.status;
+}
+function isPostHogEventProperties(value) {
+  return null !== value && "object" == typeof value && !Array.isArray(value);
+}
+var PostHogCoreStateless = class {
+  getErrorPropertiesBuilder() {
+    if (!this._errorPropertiesBuilder) this._errorPropertiesBuilder = this.createErrorPropertiesBuilder();
+    return this._errorPropertiesBuilder;
+  }
+  createErrorPropertiesBuilder() {
+    return new ErrorPropertiesBuilder([
+      new ErrorCoercer(),
+      new ObjectCoercer(),
+      new StringCoercer(),
+      new PrimitiveCoercer()
+    ], createDefaultStackParser());
   }
-  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(hint);
-    const exceptionWithStack = this.parseStacktrace(exceptionWithCause, parsingContext);
-    const exceptionList = this.convertToExceptionList(exceptionWithStack, mechanism);
-    return {
-      $exception_list: exceptionList,
-      $exception_level: "error"
+  constructor(apiKey, options = {}) {
+    this.flushPromise = null;
+    this.shutdownPromise = null;
+    this.promiseQueue = new PromiseQueue();
+    this._events = new SimpleEventEmitter();
+    this._isInitialized = false;
+    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);
+    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) || missingApiKey;
+    this.historicalMigration = options?.historicalMigration ?? false;
+    this._initPromise = Promise.resolve();
+    this._isInitialized = true;
+    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);
   }
-  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;
+  logMsgIfDebug(fn) {
+    if (this.isDebug) fn();
   }
-  coerceFallback(ctx) {
-    return {
-      type: "Error",
-      value: "Unknown error",
-      stack: ctx.syntheticException?.stack,
-      synthetic: true
-    };
+  wrap(fn) {
+    if (this.disabled) return void this._logger.warn("The client is disabled");
+    if (this._isInitialized) return fn();
+    this._initPromise.then(() => fn());
   }
-  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 ? ctx.skipFirstLines : 0), ctx.chunkIdMap);
+  getCommonEventProperties() {
     return {
-      ...err,
-      cause,
-      stack
+      $lib: this.getLibraryId(),
+      $lib_version: this.getLibraryVersion()
     };
   }
-  applyChunkIds(frames, chunkIdMap) {
-    return frames.map((frame) => {
-      if (frame.filename && chunkIdMap) frame.chunk_id = chunkIdMap[frame.filename];
-      return frame;
+  get optedOut() {
+    return this.getPersistedProperty(types_PostHogPersistedProperty.OptedOut) ?? !this.defaultOptIn;
+  }
+  async optIn() {
+    this.wrap(() => {
+      this.setPersistedProperty(types_PostHogPersistedProperty.OptedOut, false);
     });
   }
-  applyCoercers(input, ctx) {
-    for (const adapter of this.coercers) if (adapter.match(input)) return adapter.coerce(input, ctx);
-    return this.coerceFallback(ctx);
+  async optOut() {
+    this.wrap(() => {
+      this.setPersistedProperty(types_PostHogPersistedProperty.OptedOut, true);
+    });
   }
-  async applyModifiers(frames) {
-    let newFrames = frames;
-    for (const modifier of this.modifiers) newFrames = await modifier(newFrames);
-    return newFrames;
+  on(event, cb) {
+    return this._events.on(event, cb);
   }
-  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;
+  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;
+      };
+    }
   }
-  buildParsingContext(hint) {
-    const context = {
-      chunkIdMap: getFilenameToChunkIdMap(this.stackParser),
-      skipFirstLines: hint.skipFirstLines ?? 1
-    };
-    return context;
+  get isDebug() {
+    return !!this.removeDebugCallback;
   }
-  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);
+  get isDisabled() {
+    return this.disabled;
+  }
+  buildPayload(payload) {
+    return {
+      distinct_id: payload.distinct_id,
+      event: payload.event,
+      properties: {
+        ...payload.properties || {},
+        ...this.getCommonEventProperties()
       }
     };
-    const context = {
-      ...hint,
-      syntheticException: 0 == depth ? hint.syntheticException : void 0,
-      mechanism,
-      apply: (input) => coerce(input, depth),
-      next: (input) => coerce(input, depth + 1)
+  }
+  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
+      })
     };
-    return context;
+    await this.sendImmediate("identify", payload, options);
   }
-};
-
-// ../../node_modules/@posthog/core/dist/error-tracking/parsers/base.mjs
-var UNKNOWN_FUNCTION = "?";
-function createFrame(platform, filename, func, lineno, colno) {
-  const frame = {
-    platform,
-    filename,
-    function: "<anonymous>" === func ? UNKNOWN_FUNCTION : func,
-    in_app: true
-  };
-  if (!isUndefined(lineno)) frame.lineno = lineno;
-  if (!isUndefined(colno)) frame.colno = colno;
-  return frame;
-}
-
-// ../../node_modules/@posthog/core/dist/error-tracking/parsers/safari.mjs
-var extractSafariExtensionDetails = (func, filename) => {
-  const isSafariExtension = -1 !== func.indexOf("safari-extension");
-  const isSafariWebExtension = -1 !== func.indexOf("safari-web-extension");
-  return isSafariExtension || isSafariWebExtension ? [
-    -1 !== func.indexOf("@") ? func.split("@")[0] : UNKNOWN_FUNCTION,
-    isSafariExtension ? `safari-extension:${filename}` : `safari-web-extension:${filename}`
-  ] : [
-    func,
-    filename
-  ];
-};
-
-// ../../node_modules/@posthog/core/dist/error-tracking/parsers/chrome.mjs
-var chromeRegexNoFnName = /^\s*at (\S+?)(?::(\d+))(?::(\d+))\s*$/i;
-var chromeRegex = /^\s*at (?:(.+?\)(?: \[.+\])?|.*?) ?\((?:address at )?)?(?:async )?((?:<anonymous>|[-a-z]+:|.*bundle|\/)?.*?)(?::(\d+))?(?::(\d+))?\)?\s*$/i;
-var chromeEvalRegex = /\((\S*)(?::(\d+))(?::(\d+))\)/;
-var chromeStackLineParser = (line, platform) => {
-  const noFnParts = chromeRegexNoFnName.exec(line);
-  if (noFnParts) {
-    const [, filename, line2, col] = noFnParts;
-    return createFrame(platform, filename, UNKNOWN_FUNCTION, +line2, +col);
+  captureStateless(distinctId, event, properties, options) {
+    this.wrap(() => {
+      const payload = this.buildPayload({
+        distinct_id: distinctId,
+        event,
+        properties
+      });
+      this.enqueue("capture", payload, options);
+    });
   }
-  const parts = chromeRegex.exec(line);
-  if (parts) {
-    const isEval = parts[2] && 0 === parts[2].indexOf("eval");
-    if (isEval) {
-      const subMatch = chromeEvalRegex.exec(parts[2]);
-      if (subMatch) {
-        parts[2] = subMatch[1];
-        parts[3] = subMatch[2];
-        parts[4] = subMatch[3];
-      }
-    }
-    const [func, filename] = extractSafariExtensionDetails(parts[1] || UNKNOWN_FUNCTION, parts[2]);
-    return createFrame(platform, filename, func, parts[3] ? +parts[3] : void 0, parts[4] ? +parts[4] : void 0);
+  async captureStatelessImmediate(distinctId, event, properties, options) {
+    const payload = this.buildPayload({
+      distinct_id: distinctId,
+      event,
+      properties
+    });
+    await this.sendImmediate("capture", payload, options);
   }
-};
-
-// ../../node_modules/@posthog/core/dist/error-tracking/parsers/gecko.mjs
-var geckoREgex = /^\s*(.*?)(?:\((.*?)\))?(?:^|@)?((?:[-a-z]+)?:\/.*?|\[native code\]|[^@]*(?:bundle|\d+\.js)|\/[\w\-. /=]+)(?::(\d+))?(?::(\d+))?\s*$/i;
-var geckoEvalRegex = /(\S+) line (\d+)(?: > eval line \d+)* > eval/i;
-var geckoStackLineParser = (line, platform) => {
-  const parts = geckoREgex.exec(line);
-  if (parts) {
-    const isEval = parts[3] && parts[3].indexOf(" > eval") > -1;
-    if (isEval) {
-      const subMatch = geckoEvalRegex.exec(parts[3]);
-      if (subMatch) {
-        parts[1] = parts[1] || "eval";
-        parts[3] = subMatch[1];
-        parts[4] = subMatch[2];
-        parts[5] = "";
+  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
       }
-    }
-    let filename = parts[3];
-    let func = parts[1] || UNKNOWN_FUNCTION;
-    [func, filename] = extractSafariExtensionDetails(func, filename);
-    return createFrame(platform, filename, func, parts[4] ? +parts[4] : void 0, parts[5] ? +parts[5] : void 0);
+    });
+    await this.sendImmediate("alias", payload, options);
   }
-};
-
-// ../../node_modules/@posthog/core/dist/error-tracking/parsers/winjs.mjs
-var winjsRegex = /^\s*at (?:((?:\[object object\])?.+) )?\(?((?:[-a-z]+):.*?):(\d+)(?::(\d+))?\)?\s*$/i;
-var winjsStackLineParser = (line, platform) => {
-  const parts = winjsRegex.exec(line);
-  return parts ? createFrame(platform, parts[2], parts[1] || UNKNOWN_FUNCTION, +parts[3], parts[4] ? +parts[4] : void 0) : void 0;
-};
-
-// ../../node_modules/@posthog/core/dist/error-tracking/parsers/opera.mjs
-var opera10Regex = / line (\d+).*script (?:in )?(\S+)(?:: in function (\S+))?$/i;
-var opera10StackLineParser = (line, platform) => {
-  const parts = opera10Regex.exec(line);
-  return parts ? createFrame(platform, parts[2], parts[3] || UNKNOWN_FUNCTION, +parts[1]) : void 0;
-};
-var opera11Regex = / line (\d+), column (\d+)\s*(?:in (?:<anonymous function: ([^>]+)>|([^)]+))\(.*\))? in (.*):\s*$/i;
-var opera11StackLineParser = (line, platform) => {
-  const parts = opera11Regex.exec(line);
-  return parts ? createFrame(platform, parts[5], parts[3] || parts[4] || UNKNOWN_FUNCTION, +parts[1], +parts[2]) : void 0;
-};
-
-// ../../node_modules/@posthog/core/dist/error-tracking/parsers/node.mjs
-var FILENAME_MATCH = /^\s*[-]{4,}$/;
-var FULL_MATCH = /at (?:async )?(?:(.+?)\s+\()?(?:(.+):(\d+):(\d+)?|([^)]+))\)?/;
-var 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);
+  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"
       }
-      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
     };
+    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);
+    });
   }
-  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;
-}
-
-// ../../node_modules/@posthog/core/dist/error-tracking/parsers/index.mjs
-var WEBPACK_ERROR_REGEXP = /\(error: (.*)\)/;
-var 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 createDefaultStackParser() {
-  return createStackParser("web:javascript", chromeStackLineParser, geckoStackLineParser);
-}
-function createStackParser(platform, ...parsers) {
-  return (stack, skipFirstLines = 0) => {
-    const frames = [];
-    const lines = stack.split("\n");
-    for (let i2 = skipFirstLines; i2 < lines.length; i2++) {
-      const line = lines[i2];
-      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;
-      }
+  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}`;
+    const requestData = {
+      token: this.apiKey,
+      distinct_id: distinctId,
+      groups,
+      person_properties: personProperties,
+      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",
+      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) => ({
+      success: true,
+      response: normalizeFlagsResponse(response)
+    })).catch((error) => {
+      this._events.emit("error", error);
+      return {
+        success: false,
+        error: this.categorizeRequestError(error)
+      };
+    });
+  }
+  categorizeRequestError(error) {
+    if (error instanceof PostHogFetchHttpError) return {
+      type: "api_error",
+      statusCode: error.status
+    };
+    if (error instanceof PostHogFetchNetworkError) {
+      const cause = error.error;
+      if (cause instanceof Error && ("AbortError" === cause.name || "TimeoutError" === cause.name)) return {
+        type: "timeout"
+      };
+      return {
+        type: "connection_error"
+      };
     }
-    return reverseAndStripFrames(frames);
-  };
-}
-
-// ../../node_modules/@posthog/core/dist/error-tracking/coercers/dom-exception-coercer.mjs
-var DOMExceptionCoercer = class {
-  match(err) {
-    return this.isDOMException(err) || this.isDOMError(err);
+    return {
+      type: "unknown_error"
+    };
   }
-  coerce(err, ctx) {
-    const hasStack = isString(err.stack);
+  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 {
-      type: this.getType(err),
-      value: this.getValue(err),
-      stack: hasStack ? err.stack : void 0,
-      cause: err.cause ? ctx.next(err.cause) : void 0,
-      synthetic: false
+      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
     };
   }
-  getType(candidate) {
-    return this.isDOMError(candidate) ? "DOMError" : "DOMException";
-  }
-  getValue(err) {
-    const name = err.name || (this.isDOMError(err) ? "DOMError" : "DOMException");
-    const message = err.message ? `${name}: ${err.message}` : name;
-    return message;
-  }
-  isDOMException(err) {
-    return isBuiltin(err, "DOMException");
+  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;
   }
-  isDOMError(err) {
-    return isBuiltin(err, "DOMError");
+  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;
   }
-};
-
-// ../../node_modules/@posthog/core/dist/error-tracking/coercers/error-coercer.mjs
-var ErrorCoercer = class {
-  match(err) {
-    return isPlainError(err);
+  async getFeatureFlagsStateless(distinctId, groups = {}, personProperties = {}, groupProperties = {}, disableGeoip, flagKeysToEvaluate) {
+    await this._initPromise;
+    return await this.getFeatureFlagsAndPayloadsStateless(distinctId, groups, personProperties, groupProperties, disableGeoip, flagKeysToEvaluate);
   }
-  coerce(err, ctx) {
+  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 {
-      type: this.getType(err),
-      value: this.getMessage(err, ctx),
-      stack: this.getStack(err),
-      cause: err.cause ? ctx.next(err.cause) : void 0,
-      synthetic: false
+      flags: featureFlagDetails.featureFlags,
+      payloads: featureFlagDetails.featureFlagPayloads,
+      requestId: featureFlagDetails.requestId
     };
   }
-  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;
+  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 result = await this.getFlags(distinctId, groups, personProperties, groupProperties, extraPayload);
+    if (!result.success) return;
+    const flagsResponse = result.response;
+    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;
   }
-};
-
-// ../../node_modules/@posthog/core/dist/error-tracking/coercers/error-event-coercer.mjs
-var ErrorEventCoercer = class {
-  constructor() {
+  async getSurveysStateless() {
+    await this._initPromise;
+    if (this.disabled) return [];
+    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 ?? [];
   }
-  match(err) {
-    return isErrorEvent(err) && void 0 != err.error;
+  get props() {
+    if (!this._props) this._props = this.getPersistedProperty(types_PostHogPersistedProperty.Props);
+    return this._props || {};
   }
-  coerce(err, ctx) {
-    const exceptionLike = ctx.apply(err.error);
-    if (!exceptionLike) return {
-      type: "ErrorEvent",
-      value: err.message,
-      stack: ctx.syntheticException?.stack,
-      synthetic: true
-    };
-    return exceptionLike;
+  set props(val) {
+    this._props = val;
   }
-};
-
-// ../../node_modules/@posthog/core/dist/error-tracking/coercers/string-coercer.mjs
-var ERROR_TYPES_PATTERN = /^(?:[Uu]ncaught (?:exception: )?)?(?:((?:Eval|Internal|Range|Reference|Syntax|Type|URI|)Error): )?(.*)$/i;
-var StringCoercer = class {
-  match(input) {
-    return "string" == typeof input;
+  async register(properties) {
+    this.wrap(() => {
+      this.props = {
+        ...this.props,
+        ...properties
+      };
+      this.setPersistedProperty(types_PostHogPersistedProperty.Props, this.props);
+    });
   }
-  coerce(input, ctx) {
-    const [type, value] = this.getInfos(input);
-    return {
-      type: type ?? "Error",
-      value: value ?? input,
-      stack: ctx.syntheticException?.stack,
-      synthetic: true
-    };
+  async unregister(property) {
+    this.wrap(() => {
+      delete this.props[property];
+      this.setPersistedProperty(types_PostHogPersistedProperty.Props, this.props);
+    });
   }
-  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
-    ];
+  processBeforeEnqueue(message) {
+    return message;
   }
-};
-
-// ../../node_modules/@posthog/core/dist/error-tracking/types.mjs
-var severityLevels = [
-  "fatal",
-  "error",
-  "warning",
-  "log",
-  "info",
-  "debug"
-];
-
-// ../../node_modules/@posthog/core/dist/error-tracking/coercers/utils.mjs
-function extractExceptionKeysForMessage(err, maxLength = 40) {
-  const keys = Object.keys(err);
-  keys.sort();
-  if (!keys.length) return "[object has no keys]";
-  for (let i2 = keys.length; i2 > 0; i2--) {
-    const serialized = keys.slice(0, i2).join(", ");
-    if (!(serialized.length > maxLength)) {
-      if (i2 === keys.length) return serialized;
-      return serialized.length <= maxLength ? serialized : `${serialized.slice(0, maxLength)}...`;
-    }
+  async flushStorage() {
   }
-  return "";
-}
-
-// ../../node_modules/@posthog/core/dist/error-tracking/coercers/object-coercer.mjs
-var ObjectCoercer = class {
-  match(candidate) {
-    return "object" == typeof candidate && null !== candidate;
+  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()");
+      let message = this.prepareMessage(_message, options);
+      message = this.processBeforeEnqueue(message);
+      if (null === message) return;
+      message = this.normalizeMessage(message);
+      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);
+    });
   }
-  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
+  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()");
+    let message = this.prepareMessage(_message, options);
+    message = this.processBeforeEnqueue(message);
+    if (null === message) return;
+    message = this.normalizeMessage(message);
+    const data = {
+      api_key: this.apiKey,
+      batch: [
+        message
+      ],
+      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
     };
-  }
-  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;
+    try {
+      const response = await this.fetchWithRetry(url, fetchOptions);
+      await response.body?.cancel()?.catch(() => {
+      });
+    } catch (err) {
+      this._events.emit("error", err);
     }
-    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;
+  normalizeMessage(message) {
+    const { type: _type, library, library_version, ...sanitizedMessage } = message;
+    let properties = isPostHogEventProperties(sanitizedMessage.properties) ? sanitizedMessage.properties : void 0;
+    if (void 0 !== library && properties?.$lib === void 0) properties = {
+      ...properties || {},
+      $lib: library
+    };
+    if (void 0 !== library_version && properties?.$lib_version === void 0) properties = {
+      ...properties || {},
+      $lib_version: library_version
+    };
+    if (properties) sanitizedMessage.properties = properties;
+    sanitizedMessage.uuid = getEventUuid(sanitizedMessage.uuid, uuidv7);
+    return sanitizedMessage;
   }
-  getErrorPropertyFromObject(obj) {
-    for (const prop in obj) if (Object.prototype.hasOwnProperty.call(obj, prop)) {
-      const value = obj[prop];
-      if (isError(value)) return value;
+  prepareMessage(_message, options) {
+    const message = {
+      ..._message,
+      timestamp: options?.timestamp ? options?.timestamp : currentISOTime(),
+      uuid: getEventUuid(options?.uuid, uuidv7)
+    };
+    const addGeoipDisableProperty = options?.disableGeoip ?? this.disableGeoip;
+    if (addGeoipDisableProperty) {
+      if (!isPostHogEventProperties(message.properties)) message.properties = {};
+      message.properties["$geoip_disable"] = true;
     }
-  }
-  getObjectClassName(obj) {
-    try {
-      const prototype = Object.getPrototypeOf(obj);
-      return prototype ? prototype.constructor.name : void 0;
-    } catch (e) {
-      return;
+    if (message.distinctId) {
+      message.distinct_id = message.distinctId;
+      delete message.distinctId;
     }
+    return message;
   }
-};
-
-// ../../node_modules/@posthog/core/dist/error-tracking/coercers/event-coercer.mjs
-var EventCoercer = class {
-  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
-    };
+  clearFlushTimer() {
+    if (this._flushTimer) {
+      clearTimeout(this._flushTimer);
+      this._flushTimer = void 0;
+    }
   }
-};
-
-// ../../node_modules/@posthog/core/dist/error-tracking/coercers/primitive-coercer.mjs
-var PrimitiveCoercer = class {
-  match(candidate) {
-    return isPrimitive(candidate);
+  flushBackground() {
+    this.flush().catch(async (err) => {
+      await logFlushError(err);
+    });
   }
-  coerce(value, ctx) {
-    return {
-      type: "Error",
-      value: `Primitive value captured as exception: ${String(value)}`,
-      stack: ctx.syntheticException?.stack,
-      synthetic: true
-    };
+  async flush() {
+    if (this.disabled) return;
+    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;
   }
-};
-
-// ../../node_modules/@posthog/core/dist/error-tracking/coercers/promise-rejection-event.mjs
-var PromiseRejectionEventCoercer = class {
-  match(err) {
-    return isBuiltin(err, "PromiseRejectionEvent") || this.isCustomEventWrappingRejection(err);
+  getCustomHeaders() {
+    const customUserAgent = this.getCustomUserAgent();
+    const headers = {};
+    if (customUserAgent && "" !== customUserAgent) headers["User-Agent"] = customUserAgent;
+    return headers;
   }
-  isCustomEventWrappingRejection(err) {
-    if (!isEvent(err)) return false;
-    try {
-      const detail = err.detail;
-      return null != detail && "object" == typeof detail && "reason" in detail;
-    } catch {
-      return false;
+  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) => void 0 === item.message ? item.message : this.normalizeMessage(item.message));
+      const persistQueueChange = async () => {
+        const refreshedQueue = this.getPersistedProperty(types_PostHogPersistedProperty.Queue) || [];
+        const newQueue = refreshedQueue.slice(batchItems.length);
+        this.setPersistedProperty(types_PostHogPersistedProperty.Queue, newQueue);
+        queue = newQueue;
+        await this.flushStorage();
+      };
+      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 {
+        const response = await this.fetchWithRetry(url, fetchOptions, retryOptions);
+        await response.body?.cancel()?.catch(() => {
+        });
+      } 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)) await persistQueueChange();
+        this._events.emit("error", err);
+        throw err;
+      }
+      await persistQueueChange();
+      sentMessages.push(...batchMessages);
     }
+    this._events.emit("flush", sentMessages);
   }
-  coerce(err, ctx) {
-    const reason = this.getUnhandledRejectionReason(err);
-    if (isPrimitive(reason)) return {
-      type: "UnhandledRejection",
-      value: `Non-Error promise rejection captured with value: ${String(reason)}`,
-      stack: ctx.syntheticException?.stack,
-      synthetic: true
+  async _sendLogsBatch(payload) {
+    if (this.disabled) return {
+      kind: "fatal",
+      error: new Error("The client is disabled")
+    };
+    const serialized = JSON.stringify(payload);
+    const url = `${this.host}/i/v1/logs?token=${encodeURIComponent(this.apiKey)}`;
+    const gzippedPayload = this.disableCompression ? null : await gzipCompress(serialized, this.isDebug);
+    const fetchOptions = {
+      method: "POST",
+      headers: {
+        ...this.getCustomHeaders(),
+        "Content-Type": "application/json",
+        ...null !== gzippedPayload && {
+          "Content-Encoding": "gzip"
+        }
+      },
+      body: gzippedPayload || serialized
     };
-    return ctx.apply(reason);
-  }
-  getUnhandledRejectionReason(error) {
     try {
-      if ("reason" in error) return error.reason;
-      if ("detail" in error && null != error.detail && "object" == typeof error.detail && "reason" in error.detail) return error.detail.reason;
-    } catch {
-    }
-    return error;
-  }
-};
-
-// ../../node_modules/@posthog/core/dist/error-tracking/utils.mjs
-var ReduceableCache = class {
-  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);
+      await this.fetchWithRetry(url, fetchOptions, {
+        retryCheck: (err) => {
+          if (isPostHogFetchContentTooLargeError(err)) return false;
+          return isPostHogFetchError(err);
+        }
+      });
+      return {
+        kind: "ok"
+      };
+    } catch (err) {
+      if (isPostHogFetchContentTooLargeError(err)) return {
+        kind: "too-large"
+      };
+      if (err instanceof PostHogFetchNetworkError) return {
+        kind: "retry-later",
+        error: err
+      };
+      return {
+        kind: "fatal",
+        error: err
+      };
     }
   }
-};
-
-// ../../node_modules/@posthog/core/dist/error-tracking/exception-steps.mjs
-var EXCEPTION_STEP_INTERNAL_FIELDS = {
-  MESSAGE: "$message",
-  TIMESTAMP: "$timestamp"
-};
-var RESERVED_EXCEPTION_STEP_KEYS = /* @__PURE__ */ new Set([
-  EXCEPTION_STEP_INTERNAL_FIELDS.MESSAGE,
-  EXCEPTION_STEP_INTERNAL_FIELDS.TIMESTAMP
-]);
-var DEFAULT_EXCEPTION_STEPS_CONFIG = {
-  enabled: true,
-  max_bytes: 32768
-};
-function resolveExceptionStepsConfig(config) {
-  if (!config) return {
-    ...DEFAULT_EXCEPTION_STEPS_CONFIG
-  };
-  return {
-    enabled: config.enabled ?? DEFAULT_EXCEPTION_STEPS_CONFIG.enabled,
-    max_bytes: normalizePositiveInteger(config.max_bytes, DEFAULT_EXCEPTION_STEPS_CONFIG.max_bytes)
-  };
-}
-function stripReservedExceptionStepFields(properties) {
-  if (!properties) return {
-    sanitizedProperties: {},
-    droppedKeys: []
-  };
-  const droppedKeys = [];
-  const sanitizedProperties = Object.keys(properties).reduce((acc, key) => {
-    if (RESERVED_EXCEPTION_STEP_KEYS.has(key)) {
-      droppedKeys.push(key);
-      return acc;
+  async fetchWithRetry(url, options, retryOptions, requestTimeout) {
+    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;
+      }
     }
-    acc[key] = properties[key];
-    return acc;
-  }, {});
-  return {
-    sanitizedProperties,
-    droppedKeys
-  };
-}
-var ExceptionStepsBuffer = class {
-  constructor(config) {
-    this._entries = [];
-    this._totalBytes = 0;
-    this._config = resolveExceptionStepsConfig(config);
-  }
-  setConfig(config) {
-    this._config = resolveExceptionStepsConfig(config);
-    this._trimToMaxBytes();
-  }
-  add(step) {
-    const serialized = normalizeAndSerializeStep(step);
-    if (!serialized) return;
-    const bytes = getUtf8ByteLength(serialized.json);
-    if (bytes > this._config.max_bytes) return;
-    this._entries.push({
-      step: serialized.step,
-      bytes
+    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: 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);
+      return res;
+    }, {
+      ...this._retryOptions,
+      ...retryOptions
     });
-    this._totalBytes += bytes;
-    this._trimToMaxBytes();
-  }
-  getAttachable() {
-    return this._entries.map((e) => e.step);
-  }
-  clear() {
-    this._entries = [];
-    this._totalBytes = 0;
-  }
-  size() {
-    return this._entries.length;
   }
-  _trimToMaxBytes() {
-    while (this._totalBytes > this._config.max_bytes && this._entries.length > 0) {
-      const evicted = this._entries.shift();
-      if (evicted) this._totalBytes -= evicted.bytes;
-    }
-  }
-};
-function normalizePositiveInteger(input, fallback) {
-  if (!isNumber(input) || input === 1 / 0 || input === -1 / 0) return fallback;
-  const normalized = Math.floor(input);
-  if (normalized < 0) return fallback;
-  return normalized;
-}
-function normalizeAndSerializeStep(step) {
-  const json = safeStringify(step);
-  if (!json) return;
-  try {
-    const parsed = JSON.parse(json);
-    if (!isObject(parsed)) return;
-    const parsedStep = parsed;
-    const message = parsedStep[EXCEPTION_STEP_INTERNAL_FIELDS.MESSAGE];
-    const timestamp = parsedStep[EXCEPTION_STEP_INTERNAL_FIELDS.TIMESTAMP];
-    if (!isString(message) || 0 === message.trim().length) return;
-    if (!isString(timestamp) && !isNumber(timestamp)) return;
-    return {
-      step: parsedStep,
-      json
+  async _shutdown(shutdownTimeoutMs = 3e4) {
+    await this._initPromise;
+    let hasTimedOut = false;
+    this.clearFlushTimer();
+    if (this.disabled) return;
+    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);
+      }
     };
-  } catch {
-    return;
+    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);
+    }
   }
-}
-function safeStringify(value) {
-  const seen = /* @__PURE__ */ new WeakSet();
-  try {
-    return JSON.stringify(value, (_key, replacementValue) => {
-      if ("bigint" == typeof replacementValue) return replacementValue.toString();
-      if ("function" == typeof replacementValue || "symbol" == typeof replacementValue) return;
-      if (replacementValue instanceof Date) return replacementValue.toISOString();
-      if (replacementValue instanceof Error) return {
-        name: replacementValue.name,
-        message: replacementValue.message,
-        stack: replacementValue.stack
-      };
-      if (replacementValue && "object" == typeof replacementValue) {
-        if (seen.has(replacementValue)) return "[Circular]";
-        seen.add(replacementValue);
-      }
-      return replacementValue;
+  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;
     });
-  } catch {
-    return;
+    return this.shutdownPromise;
   }
-}
-function getUtf8ByteLength(value) {
-  if ("undefined" != typeof TextEncoder) return new TextEncoder().encode(value).length;
-  const encoded = encodeURIComponent(value);
-  let byteLength = 0;
-  for (let i2 = 0; i2 < encoded.length; i2++) if ("%" === encoded[i2]) {
-    byteLength += 1;
-    i2 += 2;
-  } else byteLength += 1;
-  return byteLength;
-}
+};
 
 // ../../node_modules/posthog-node/dist/extensions/error-tracking/modifiers/context-lines.node.mjs
 import { createReadStream } from "node:fs";
@@ -3450,137 +3618,38 @@ function emplace(map, key, 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;
-}
-
-// ../../node_modules/posthog-node/dist/extensions/error-tracking/modifiers/relative-path.node.mjs
-import { isAbsolute as isAbsolute2, relative, sep as sep2 } from "path";
-function createRelativePathModifier(basePath = process.cwd()) {
-  const isWindows = "\\" === sep2;
-  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 (isAbsolute2(frame.filename)) frame.filename = toUnix(relative(normalizedBase, toUnix(frame.filename)));
-    }
-    return frames;
-  };
-}
-
-// ../../node_modules/posthog-node/dist/extensions/error-tracking/autocapture.mjs
-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
-    }
-  }));
+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;
 }
 
-// ../../node_modules/posthog-node/dist/extensions/error-tracking/index.mjs
-var SHUTDOWN_TIMEOUT = 2e3;
-var ErrorTracking = 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
-    };
-    const exceptionProperties = this.errorPropertiesBuilder.buildFromUnknown(error, hint);
-    exceptionProperties.$exception_list = await this.errorPropertiesBuilder.modifyFrames(exceptionProperties.$exception_list);
-    return {
-      event: "$exception",
-      distinctId,
-      properties: {
-        ...exceptionProperties,
-        ...properties
-      },
-      _originatedFromCaptureException: true
-    };
-  }
-  startAutocaptureIfEnabled() {
-    if (this.isEnabled()) {
-      addUncaughtExceptionListener(this.onException.bind(this), this.onFatalError.bind(this));
-      addUnhandledRejectionListener(this.onException.bind(this));
+// ../../node_modules/posthog-node/dist/extensions/error-tracking/modifiers/relative-path.node.mjs
+import { isAbsolute as isAbsolute2, relative, sep as sep2 } from "path";
+function createRelativePathModifier(basePath = process.cwd()) {
+  const isWindows = "\\" === sep2;
+  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 (isAbsolute2(frame.filename)) frame.filename = toUnix(relative(normalizedBase, toUnix(frame.filename)));
     }
-  }
-  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();
-  }
-};
+    return frames;
+  };
+}
 
 // ../../node_modules/posthog-node/dist/version.mjs
-var version = "5.35.0";
+var version = "5.38.6";
 
 // ../../node_modules/posthog-node/dist/types.mjs
 var FeatureFlagError2 = {
@@ -3732,20 +3801,21 @@ var ClientError = class _ClientError extends Error {
     Object.setPrototypeOf(this, _ClientError.prototype);
   }
 };
+function setCustomErrorPrototype(error, constructor) {
+  error.name = constructor.name;
+  Error.captureStackTrace(error, constructor);
+  Object.setPrototypeOf(error, constructor.prototype);
+}
 var InconclusiveMatchError = class _InconclusiveMatchError extends Error {
   constructor(message) {
     super(message);
-    this.name = this.constructor.name;
-    Error.captureStackTrace(this, this.constructor);
-    Object.setPrototypeOf(this, _InconclusiveMatchError.prototype);
+    setCustomErrorPrototype(this, _InconclusiveMatchError);
   }
 };
 var RequiresServerEvaluation = class _RequiresServerEvaluation extends Error {
   constructor(message) {
     super(message);
-    this.name = this.constructor.name;
-    Error.captureStackTrace(this, this.constructor);
-    Object.setPrototypeOf(this, _RequiresServerEvaluation.prototype);
+    setCustomErrorPrototype(this, _RequiresServerEvaluation);
   }
 };
 var FeatureFlagsPoller = class {
@@ -3937,6 +4007,7 @@ var FeatureFlagsPoller = class {
     const flagFilters = flag.filters || {};
     const flagConditions = flagFilters.groups || [];
     const flagAggregation = flagFilters.aggregation_group_type_index;
+    const earlyExitEnabled = flagFilters.early_exit ?? false;
     const { groups, groupProperties } = evaluationContext;
     let isInconclusive = false;
     let result;
@@ -3959,12 +4030,14 @@ var FeatureFlagsPoller = class {
           effectiveBucketingValue = groups[groupName];
         }
       }
-      if (await this.isConditionMatch(flag, effectiveBucketingValue, condition, effectiveProperties, evaluationContext)) {
+      const matchResult = await this.isConditionMatch(flag, effectiveBucketingValue, condition, effectiveProperties, evaluationContext);
+      if ("match" === matchResult) {
         const variantOverride = condition.variant;
         const flagVariants = flagFilters.multivariate?.variants || [];
         result = variantOverride && flagVariants.some((variant) => variant.key === variantOverride) ? variantOverride : await this.getMatchingVariant(flag, effectiveBucketingValue) || true;
         break;
       }
+      if (earlyExitEnabled && "out_of_rollout_bound" === matchResult) return false;
     } catch (e) {
       if (e instanceof RequiresServerEvaluation) throw e;
       if (e instanceof InconclusiveMatchError) isInconclusive = true;
@@ -3984,12 +4057,12 @@ var FeatureFlagsPoller = class {
         const propertyType = prop.type;
         let matches2 = false;
         matches2 = "cohort" === propertyType ? await matchCohort(prop, properties, this.cohorts, this.debugMode, (depProp) => this.evaluateFlagDependency(depProp, properties, evaluationContext)) : "flag" === propertyType ? await this.evaluateFlagDependency(prop, properties, evaluationContext) : matchProperty(prop, properties, warnFunction);
-        if (!matches2) return false;
+        if (!matches2) return "no_match";
       }
-      if (void 0 == rolloutPercentage) return true;
+      if (void 0 == rolloutPercentage) return "match";
     }
-    if (void 0 != rolloutPercentage && await _hash(flag.key, bucketingValue) > rolloutPercentage / 100) return false;
-    return true;
+    if (void 0 != rolloutPercentage && await _hash(flag.key, bucketingValue) > rolloutPercentage / 100) return "out_of_rollout_bound";
+    return "match";
   }
   async getMatchingVariant(flag, bucketingValue) {
     const hashValue = await _hash(flag.key, bucketingValue, "variant");
@@ -4507,6 +4580,105 @@ function relativeDateParseForFeatureFlagMatching(value) {
   }
 }
 
+// ../../node_modules/posthog-node/dist/extensions/error-tracking/autocapture.mjs
+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
+    }
+  }));
+}
+
+// ../../node_modules/posthog-node/dist/extensions/error-tracking/index.mjs
+var SHUTDOWN_TIMEOUT = 2e3;
+var ErrorTracking = 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(builder, error, hint, distinctId, additionalProperties) {
+    const properties = {
+      ...additionalProperties
+    };
+    const exceptionProperties = builder.buildFromUnknown(error, hint);
+    exceptionProperties.$exception_list = await builder.modifyFrames(exceptionProperties.$exception_list);
+    return {
+      event: "$exception",
+      distinctId,
+      properties: {
+        ...exceptionProperties,
+        ...properties
+      },
+      _originatedFromCaptureException: true
+    };
+  }
+  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(this.client.getErrorPropertiesBuilder(), 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();
+  }
+};
+
 // ../../node_modules/posthog-node/dist/storage-memory.mjs
 var PostHogMemoryStorage = class {
   getProperty(key) {
@@ -4544,6 +4716,12 @@ function normalizeHost(value) {
   const normalizedValue = "string" == typeof value ? value.trim() : "";
   return normalizedValue || DEFAULT_NODE_HOST;
 }
+function normalizeUnsetPersonProperties(value) {
+  const propertyNames = Array.isArray(value) ? value : [
+    value
+  ];
+  return propertyNames.filter((propertyName) => "string" == typeof propertyName && propertyName.trim().length > 0);
+}
 function buildFlagEventProperties(flagValues) {
   if (!flagValues) return {};
   const additionalProperties = {};
@@ -4566,7 +4744,7 @@ var PostHogBackendClient = class extends PostHogCoreStateless {
     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 (!this.disabled && 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({
@@ -4667,6 +4845,11 @@ var PostHogBackendClient = class extends PostHogCoreStateless {
   getCustomUserAgent() {
     return `${this.getLibraryId()}/${this.getLibraryVersion()}`;
   }
+  getCommonEventProperties() {
+    const commonProperties = super.getCommonEventProperties();
+    if (this.options.isServer ?? true) commonProperties.$is_server = true;
+    return commonProperties;
+  }
   enable() {
     return super.optIn();
   }
@@ -4677,27 +4860,29 @@ var PostHogBackendClient = class extends PostHogCoreStateless {
     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.");
-    if ("$exception" === props.event && !props._originatedFromCaptureException) this._logger.warn("Using `posthog.capture('$exception')` is unreliable because it does not attach required metadata. Use `posthog.captureException(error)` instead, which attaches required metadata automatically.");
-    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) => {
+  _warnIfInvalidCapture(props, stringArgumentWarning, exceptionCaptureWarning) {
+    if ("string" == typeof props) this._logger.warn(stringArgumentWarning);
+    if ("$exception" === props.event && !props._originatedFromCaptureException) this._logger.warn(exceptionCaptureWarning);
+  }
+  _capturePreparedEvent(props, immediate) {
+    return this.addPendingPromise(this.prepareEventMessage(props).then(({ distinctId, event, properties, options }) => {
+      const captureOptions = {
+        timestamp: options.timestamp,
+        disableGeoip: options.disableGeoip,
+        uuid: options.uuid
+      };
+      return immediate ? super.captureStatelessImmediate(distinctId, event, properties, captureOptions) : super.captureStateless(distinctId, event, properties, captureOptions);
+    }).catch((err) => {
       if (err) console.error(err);
     }));
   }
+  capture(props) {
+    this._warnIfInvalidCapture(props, "Called capture() with a string as the first argument when an object was expected.", "Using `posthog.capture('$exception')` is unreliable because it does not attach required metadata. Use `posthog.captureException(error)` instead, which attaches required metadata automatically.");
+    this._capturePreparedEvent(props, false);
+  }
   async captureImmediate(props) {
-    if ("string" == typeof props) this._logger.warn("Called captureImmediate() with a string as the first argument when an object was expected.");
-    if ("$exception" === props.event && !props._originatedFromCaptureException) this._logger.warn("Capturing a `$exception` event via `posthog.captureImmediate('$exception')` is unreliable because it does not attach required metadata. Use `posthog.captureExceptionImmediate(error)` instead, which attaches this metadata by default.");
-    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);
-    }));
+    this._warnIfInvalidCapture(props, "Called captureImmediate() with a string as the first argument when an object was expected.", "Capturing a `$exception` event via `posthog.captureImmediate('$exception')` is unreliable because it does not attach required metadata. Use `posthog.captureExceptionImmediate(error)` instead, which attaches this metadata by default.");
+    return this._capturePreparedEvent(props, true);
   }
   identify({ distinctId, properties = {}, disableGeoip }) {
     const { $set, $set_once, $anon_distinct_id, ...rest } = properties;
@@ -4725,6 +4910,28 @@ var PostHogBackendClient = class extends PostHogCoreStateless {
       disableGeoip
     });
   }
+  setPersonProperties({ distinctId, properties = {}, propertiesOnce = {} }) {
+    if (0 === Object.keys(properties).length && 0 === Object.keys(propertiesOnce).length) return;
+    const eventProperties = {};
+    if (Object.keys(properties).length > 0) eventProperties.$set = properties;
+    if (Object.keys(propertiesOnce).length > 0) eventProperties.$set_once = propertiesOnce;
+    this.capture({
+      distinctId,
+      event: "$set",
+      properties: eventProperties
+    });
+  }
+  unsetPersonProperties({ distinctId, properties }) {
+    const propertyNames = normalizeUnsetPersonProperties(properties);
+    if (0 === propertyNames.length) return;
+    this.capture({
+      distinctId,
+      event: "$set",
+      properties: {
+        $unset: propertyNames
+      }
+    });
+  }
   alias(data) {
     super.aliasStateless(data.alias, data.distinctId, void 0, {
       disableGeoip: data.disableGeoip
@@ -4764,6 +4971,7 @@ var PostHogBackendClient = class extends PostHogCoreStateless {
     };
   }
   async _getFeatureFlagResult(key, distinctId, options = {}, matchValue) {
+    if (this.disabled) return void this._logger.warn("The client is disabled");
     const sendFeatureFlagEvents = options.sendFeatureFlagEvents ?? true;
     if (void 0 !== this._flagOverrides && key in this._flagOverrides) {
       const overrideValue = this._flagOverrides[key];
@@ -4911,6 +5119,7 @@ var PostHogBackendClient = class extends PostHogCoreStateless {
     });
   }
   async getRemoteConfigPayload(flagKey) {
+    if (this.disabled) return void this._logger.warn("The client is disabled");
     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;
@@ -4950,6 +5159,13 @@ var PostHogBackendClient = class extends PostHogCoreStateless {
         featureFlagPayloads: {}
       };
     }
+    if (this.disabled) {
+      this._logger.warn("The client is disabled");
+      return {
+        featureFlags: {},
+        featureFlagPayloads: {}
+      };
+    }
     const { groups, disableGeoip, flagKeys } = resolvedOptions || {};
     let { onlyEvaluateLocally, personProperties, groupProperties } = resolvedOptions || {};
     const adjustedProperties = this.addLocalPersonAndGroupProperties(resolvedDistinctId, groups, personProperties, groupProperties);
@@ -5000,6 +5216,14 @@ var PostHogBackendClient = class extends PostHogCoreStateless {
         flags: {}
       });
     }
+    if (this.disabled) {
+      this._logger.warn("The client is disabled");
+      return new FeatureFlagEvaluations({
+        host: this._getFeatureFlagEvaluationsHost(),
+        distinctId: resolvedDistinctId,
+        flags: {}
+      });
+    }
     const { groups, disableGeoip, flagKeys } = resolvedOptions || {};
     let { onlyEvaluateLocally, personProperties, groupProperties } = resolvedOptions || {};
     const adjustedProperties = this.addLocalPersonAndGroupProperties(resolvedDistinctId, groups, personProperties, groupProperties);
@@ -5096,13 +5320,14 @@ var PostHogBackendClient = class extends PostHogCoreStateless {
   }
   _captureFlagCalledEventIfNeeded(params) {
     const { distinctId, key, response, groups, disableGeoip, properties } = params;
-    const featureFlagReportedKey = `${key}_${response}`;
-    if (distinctId in this.distinctIdHasSentFlagCalls && this.distinctIdHasSentFlagCalls[distinctId].includes(featureFlagReportedKey)) return;
+    const groupSuffix = groups && Object.keys(groups).length > 0 ? `_${JSON.stringify(Object.entries(groups).sort(([a2], [b]) => a2 < b ? -1 : a2 > b ? 1 : 0))}` : "";
+    const featureFlagReportedKey = `${key}_${response}${groupSuffix}`;
+    if (distinctId in this.distinctIdHasSentFlagCalls && this.distinctIdHasSentFlagCalls[distinctId].has(featureFlagReportedKey)) return;
     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] = [
+    if (this.distinctIdHasSentFlagCalls[distinctId] instanceof Set) this.distinctIdHasSentFlagCalls[distinctId].add(featureFlagReportedKey);
+    else this.distinctIdHasSentFlagCalls[distinctId] = /* @__PURE__ */ new Set([
       featureFlagReportedKey
-    ];
+    ]);
     this.capture({
       distinctId,
       event: "$feature_flag_called",
@@ -5192,11 +5417,12 @@ var PostHogBackendClient = class extends PostHogCoreStateless {
     try {
       return await super._shutdown(shutdownTimeoutMs);
     } finally {
+      this.distinctIdHasSentFlagCalls = {};
       resolve3?.();
     }
   }
   async _requestRemoteConfigPayload(flagKey) {
-    if (!this.options.personalApiKey) return;
+    if (this.disabled || !this.apiKey || !this.options.personalApiKey) return;
     const url = `${this.host}/api/projects/@current/feature_flags/${flagKey}/remote_config?token=${encodeURIComponent(this.apiKey)}`;
     const options = {
       method: "GET",
@@ -5241,6 +5467,7 @@ var PostHogBackendClient = class extends PostHogCoreStateless {
     };
   }
   async getFeatureFlagsForEvent(distinctId, groups, disableGeoip, sendFeatureFlagsOptions) {
+    if (this.disabled || !this.apiKey) return void this._logger.warn("The client is disabled");
     const finalPersonProperties = sendFeatureFlagsOptions?.personProperties || {};
     const finalGroupProperties = sendFeatureFlagsOptions?.groupProperties || {};
     const flagKeys = sendFeatureFlagsOptions?.flagKeys;
@@ -5299,7 +5526,7 @@ var PostHogBackendClient = class extends PostHogCoreStateless {
   captureException(error, distinctId, additionalProperties, uuid, flags2) {
     if (!ErrorTracking.isPreviouslyCapturedError(error)) {
       const syntheticException = new Error("PostHog syntheticException");
-      this.addPendingPromise(ErrorTracking.buildEventMessage(error, {
+      this.addPendingPromise(ErrorTracking.buildEventMessage(this.getErrorPropertiesBuilder(), error, {
         syntheticException
       }, distinctId, additionalProperties).then((msg) => this.capture({
         ...msg,
@@ -5311,7 +5538,7 @@ var PostHogBackendClient = class extends PostHogCoreStateless {
   async captureExceptionImmediate(error, distinctId, additionalProperties, flags2) {
     if (!ErrorTracking.isPreviouslyCapturedError(error)) {
       const syntheticException = new Error("PostHog syntheticException");
-      return this.addPendingPromise(ErrorTracking.buildEventMessage(error, {
+      return this.addPendingPromise(ErrorTracking.buildEventMessage(this.getErrorPropertiesBuilder(), error, {
         syntheticException
       }, distinctId, additionalProperties).then((msg) => this.captureImmediate({
         ...msg,
@@ -5358,12 +5585,14 @@ var PostHogBackendClient = class extends PostHogCoreStateless {
       }
       return {};
     }).catch(() => ({})).then((additionalProperties) => {
-      const props2 = {
+      const resolvedGroups = eventMessage.groups || groups;
+      return {
         ...additionalProperties,
         ...eventMessage.properties || {},
-        $groups: eventMessage.groups || groups
+        ...void 0 !== resolvedGroups && Object.keys(resolvedGroups).length > 0 ? {
+          $groups: resolvedGroups
+        } : {}
       };
-      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 || [])) {
@@ -5498,17 +5727,6 @@ var PostHogSentryIntegration = class {
 };
 
 // ../../node_modules/posthog-node/dist/entrypoints/index.node.mjs
-ErrorTracking.errorPropertiesBuilder = new error_tracking_exports.ErrorPropertiesBuilder([
-  new error_tracking_exports.EventCoercer(),
-  new error_tracking_exports.ErrorCoercer(),
-  new error_tracking_exports.ObjectCoercer(),
-  new error_tracking_exports.StringCoercer(),
-  new error_tracking_exports.PrimitiveCoercer()
-], error_tracking_exports.createStackParser("node:javascript", error_tracking_exports.nodeStackLineParser), [
-  createModulerModifier(),
-  addSourceContext,
-  createRelativePathModifier()
-]);
 var PostHog = class extends PostHogBackendClient {
   getLibraryId() {
     return "posthog-node";
@@ -5516,6 +5734,19 @@ var PostHog = class extends PostHogBackendClient {
   initializeContext() {
     return new PostHogContext();
   }
+  createErrorPropertiesBuilder() {
+    return new error_tracking_exports.ErrorPropertiesBuilder([
+      new error_tracking_exports.EventCoercer(),
+      new error_tracking_exports.ErrorCoercer(),
+      new error_tracking_exports.ObjectCoercer(),
+      new error_tracking_exports.StringCoercer(),
+      new error_tracking_exports.PrimitiveCoercer()
+    ], error_tracking_exports.createStackParser("node:javascript", error_tracking_exports.nodeStackLineParser), [
+      createModulerModifier(),
+      addSourceContext,
+      createRelativePathModifier()
+    ]);
+  }
 };
 
 // ../telemetry/src/posthog.ts
@@ -5606,6 +5837,8 @@ var FAILURE_CODES = {
   UNINSTALL_TOOLSERVER_STOP_FAILED: "UNINSTALL_TOOLSERVER_STOP_FAILED",
   UNINSTALL_PACKAGE_ACTION_FAILED: "UNINSTALL_PACKAGE_ACTION_FAILED",
   UNINSTALL_UNCLASSIFIED_FAILED: "UNINSTALL_UNCLASSIFIED_FAILED",
+  VEGA_CLI_COMMAND_FAILED: "VEGA_CLI_COMMAND_FAILED",
+  VEGA_INPUT_UNAVAILABLE: "VEGA_INPUT_UNAVAILABLE",
   ANDROID_ADB_NOT_FOUND: "ANDROID_ADB_NOT_FOUND",
   ANDROID_EMULATOR_NOT_FOUND: "ANDROID_EMULATOR_NOT_FOUND",
   ANDROID_ADB_COMMAND_FAILED: "ANDROID_ADB_COMMAND_FAILED",
@@ -5754,6 +5987,7 @@ var FAILURE_KINDS = [
 var FAILURE_COMMANDS = [
   "adb",
   "emulator",
+  "vega",
   "xcrun_simctl",
   "xctrace",
   "native_devtools",
@@ -5794,7 +6028,7 @@ var FAILURE_SPAWN_CODE_SET = new Set(FAILURE_SPAWN_CODES);
 import { randomUUID as randomUUID2 } from "node:crypto";
 
 // ../telemetry/src/events.ts
-var PLATFORMS = ["ios", "android", "chromium"];
+var PLATFORMS = ["ios", "ios-remote", "android", "chromium", "vega"];
 
 // ../telemetry/src/ai-identity.ts
 var AI_CLIENTS = [
@@ -5972,8 +6206,7 @@ var ALLOWED = {
     uptime_ms: DURATION_MS,
     total_tool_calls: COUNT,
     ...FAILURE_SIGNAL
-  },
-  "telemetry:opt_out": {}
+  }
 };
 function sanitize(event, raw) {
   const validators = ALLOWED[event];
@@ -5991,6 +6224,56 @@ function sanitize(event, raw) {
 // ../telemetry/src/base-props.ts
 import { randomUUID as randomUUID3 } from "node:crypto";
 
+// ../telemetry/src/cloud-agent-detect.ts
+import { existsSync as existsSync2 } from "node:fs";
+var CLAUDE_CLOUD_ENV_KINDS = /* @__PURE__ */ new Set(["byoc", "anthropic_cloud"]);
+var CLAUDE_REMOTE_ENTRYPOINTS = /* @__PURE__ */ new Set([
+  "remote",
+  "remote_baku",
+  "remote_cowork",
+  "remote_desktop",
+  "remote_mobile",
+  "claude-in-teams"
+]);
+function isClaudeCodeCloud(env) {
+  const kind = env.CLAUDE_CODE_ENVIRONMENT_KIND;
+  if (kind && CLAUDE_CLOUD_ENV_KINDS.has(kind)) return true;
+  const entrypoint = env.CLAUDE_CODE_ENTRYPOINT;
+  if (entrypoint && CLAUDE_REMOTE_ENTRYPOINTS.has(entrypoint)) return true;
+  return Boolean(env.CLAUDE_CODE_REMOTE_SESSION_ID);
+}
+function isCursorCloud(env) {
+  return Boolean(env.CURSOR_AGENT_WORKER_ID) || Boolean(env.CURSOR_WORKER_POOL_NAME);
+}
+function isCopilotAgent(env) {
+  if (!env.GITHUB_ACTIONS) return false;
+  const actor = (env.GITHUB_ACTOR ?? "").toLowerCase();
+  const workflowRef = (env.GITHUB_WORKFLOW_REF ?? "").toLowerCase();
+  return actor === "copilot" || actor.includes("copilot-swe-agent") || workflowRef.includes("copilot-swe-agent");
+}
+function isReplitAgent(env) {
+  return Boolean(env.REPLIT_AGENT);
+}
+var DEVIN_MARKER_PATH = "/opt/.devin";
+var JULES_MARKER_PATH = "/opt/environment_summary.sh";
+function safeExists(fileExists, path10) {
+  try {
+    return fileExists(path10);
+  } catch {
+    return false;
+  }
+}
+function detectCloudAgent(env = process.env, opts = {}) {
+  if (isClaudeCodeCloud(env)) return "claude_code";
+  if (isCursorCloud(env)) return "cursor";
+  if (isCopilotAgent(env)) return "copilot";
+  if (isReplitAgent(env)) return "replit";
+  const fileExists = opts.fileExists ?? existsSync2;
+  if (safeExists(fileExists, DEVIN_MARKER_PATH)) return "devin";
+  if (safeExists(fileExists, JULES_MARKER_PATH)) return "jules";
+  return null;
+}
+
 // ../../node_modules/ci-info/vendors.json
 var vendors_default = [
   {
@@ -6396,7 +6679,7 @@ var _CI_VENDOR_COUNT_FOR_TEST = vendors_default.length;
 var SESSION_ID2 = randomUUID3();
 function readCliVersion() {
   if (true) {
-    return "0.12.1";
+    return "0.13.0";
   }
   return "0.0.0";
 }
@@ -6414,6 +6697,7 @@ function getInvariantProps() {
       arch: process.arch,
       is_tty: Boolean(process.stdout.isTTY),
       is_ci: isCi(),
+      cloud_agent: detectCloudAgent(),
       $process_person_profile: false
     };
   }
@@ -6543,7 +6827,7 @@ function readConfigObject() {
   }
   return {};
 }
-var LOCK_STALE_MS = 1e4;
+var LOCK_STALE_MS2 = 1e4;
 var LOCK_MAX_WAIT_MS = 2e3;
 var LOCK_RETRY_MS = 25;
 function sleepSync(ms) {
@@ -6564,7 +6848,7 @@ function acquireConfigLock() {
     } catch (err) {
       if (err.code !== "EEXIST") return null;
       try {
-        if (Date.now() - fs3.statSync(lockPath).mtimeMs > LOCK_STALE_MS) {
+        if (Date.now() - fs3.statSync(lockPath).mtimeMs > LOCK_STALE_MS2) {
           fs3.unlinkSync(lockPath);
           continue;
         }
@@ -6828,39 +7112,12 @@ async function shutdown(timeoutMs = SHORT_FLUSH_TIMEOUT_MS) {
     state = null;
   }
 }
-function isEnabled2() {
-  return isEnabled();
-}
 function markEnabled() {
   writeConsentFlag(true);
 }
 async function markDisabled() {
   try {
-    const wasEnabled = isEnabled();
-    let client2 = getConstructedClient();
-    if (wasEnabled && peekAnonId() !== null) {
-      const built = buildPayload("telemetry:opt_out", {});
-      if (built && isDebugEnabled()) {
-        emitDebugPayload({
-          event: "telemetry:opt_out",
-          distinctId: built.distinctId,
-          properties: built.properties,
-          ts: (/* @__PURE__ */ new Date()).toISOString()
-        });
-      }
-      client2 = getClient();
-      if (built && client2) {
-        try {
-          client2.capture({
-            distinctId: built.distinctId,
-            event: "telemetry:opt_out",
-            properties: built.properties
-          });
-        } catch (err) {
-          emitDebugError("markDisabled: capture(telemetry:opt_out) failed", err);
-        }
-      }
-    }
+    const client2 = getConstructedClient();
     writeConsentFlag(false);
     if (client2) {
       try {
@@ -7663,6 +7920,9 @@ async function runDetached(paths, port, host, idleTimeoutMinutes, token) {
     startedAt: (/* @__PURE__ */ new Date()).toISOString(),
     bundlePath: paths.bundlePath,
     host,
+    // Mark this as an explicitly-started (possibly supervisor-managed) server so
+    // the MCP auto-spawn path's kill-before-respawn never terminates it.
+    managed: "cli",
     ...token ? { token } : {}
   });
   const url = formatUrl(host, actualPort);
@@ -7703,6 +7963,8 @@ async function runForeground(paths, port, host, idleTimeoutMinutes, token) {
         startedAt: (/* @__PURE__ */ new Date()).toISOString(),
         bundlePath: paths.bundlePath,
         host,
+        // See runDetached: tag CLI-started servers so auto-spawn won't kill them.
+        managed: "cli",
         ...token ? { token } : {}
       });
       stateWritten = true;
@@ -8790,7 +9052,7 @@ var n = class extends V {
 import { styleText as styleText2, stripVTControlCharacters } from "node:util";
 import process$1 from "node:process";
 var import_sisteransi2 = __toESM(require_src(), 1);
-import { existsSync as existsSync3, lstatSync as lstatSync3, readdirSync as readdirSync2 } from "node:fs";
+import { existsSync as existsSync5, lstatSync as lstatSync3, readdirSync as readdirSync2 } from "node:fs";
 import { dirname as dirname5, join as join9 } from "node:path";
 function isUnicodeSupported() {
   if (process$1.platform !== "win32") {
@@ -8800,7 +9062,7 @@ function isUnicodeSupported() {
 }
 var unicode = isUnicodeSupported();
 var isCI = () => process.env.CI === "true";
-var unicodeOr = (e, o2) => unicode ? e : o2;
+var unicodeOr = (o2, e) => unicode ? o2 : e;
 var S_STEP_ACTIVE = unicodeOr("\u25C6", "*");
 var S_STEP_CANCEL = unicodeOr("\u25A0", "x");
 var S_STEP_ERROR = unicodeOr("\u25B2", "x");
@@ -8826,8 +9088,8 @@ var S_INFO = unicodeOr("\u25CF", "\u2022");
 var S_SUCCESS = unicodeOr("\u25C6", "*");
 var S_WARN = unicodeOr("\u25B2", "!");
 var S_ERROR = unicodeOr("\u25A0", "x");
-var symbol = (e) => {
-  switch (e) {
+var symbol = (o2) => {
+  switch (o2) {
     case "initial":
     case "active":
       return styleText2("cyan", S_STEP_ACTIVE);
@@ -8839,8 +9101,8 @@ var symbol = (e) => {
       return styleText2("green", S_STEP_SUBMIT);
   }
 };
-var symbolBar = (e) => {
-  switch (e) {
+var symbolBar = (o2) => {
+  switch (o2) {
     case "initial":
     case "active":
       return styleText2("cyan", S_BAR);
@@ -8852,6 +9114,10 @@ var symbolBar = (e) => {
       return styleText2("green", S_BAR);
   }
 };
+function formatInstructionFooter(o2, e) {
+  const r2 = [`${e ? `${styleText2("cyan", S_BAR)}  ` : ""}${o2.join(" \u2022 ")}`];
+  return e && r2.push(styleText2("cyan", S_BAR_END)), r2;
+}
 var E$1 = (l2, o2, g, c2, h2, O = false) => {
   let r2 = o2, w = 0;
   if (O)
@@ -8954,6 +9220,11 @@ ${g}
     }
   }).prompt();
 };
+var MULTISELECT_INSTRUCTIONS = [
+  `${styleText2("dim", "\u2191/\u2193")} to navigate`,
+  `${styleText2("dim", "Space:")} select`,
+  `${styleText2("dim", "Enter:")} confirm`
+];
 var log = {
   message: (s = [], {
     symbol: e = styleText2("gray", S_BAR),
@@ -9100,20 +9371,24 @@ var u2 = {
   heavy: unicodeOr("\u2501", "="),
   block: unicodeOr("\u2588", "#")
 };
-var c = (e, a2) => e.includes(`
-`) ? e.split(`
-`).map((t2) => a2(t2)).join(`
-`) : a2(e);
-var select = (e) => {
-  const a2 = (t2, d) => {
-    const s = t2.label ?? String(t2.value);
-    switch (d) {
+var SELECT_INSTRUCTIONS = [
+  `${styleText2("dim", "\u2191/\u2193")} to navigate`,
+  `${styleText2("dim", "Enter:")} confirm`
+];
+var c = (t2, a2) => t2.includes(`
+`) ? t2.split(`
+`).map((i2) => a2(i2)).join(`
+`) : a2(t2);
+var select = (t2) => {
+  const a2 = (i2, m) => {
+    const s = i2.label ?? String(i2.value);
+    switch (m) {
       case "disabled":
-        return `${styleText2("gray", S_RADIO_INACTIVE)} ${c(s, (n2) => styleText2("gray", n2))}${t2.hint ? ` ${styleText2("dim", `(${t2.hint ?? "disabled"})`)}` : ""}`;
+        return `${styleText2("gray", S_RADIO_INACTIVE)} ${c(s, (n2) => styleText2("gray", n2))}${i2.hint ? ` ${styleText2("dim", `(${i2.hint ?? "disabled"})`)}` : ""}`;
       case "selected":
         return `${c(s, (n2) => styleText2("dim", n2))}`;
       case "active":
-        return `${styleText2("green", S_RADIO_ACTIVE)} ${s}${t2.hint ? ` ${styleText2("dim", `(${t2.hint})`)}` : ""}`;
+        return `${styleText2("green", S_RADIO_ACTIVE)} ${s}${i2.hint ? ` ${styleText2("dim", `(${i2.hint})`)}` : ""}`;
       case "cancelled":
         return `${c(s, (n2) => styleText2(["strikethrough", "dim"], n2))}`;
       default:
@@ -9121,52 +9396,53 @@ var select = (e) => {
     }
   };
   return new a({
-    options: e.options,
-    signal: e.signal,
-    input: e.input,
-    output: e.output,
-    initialValue: e.initialValue,
+    options: t2.options,
+    signal: t2.signal,
+    input: t2.input,
+    output: t2.output,
+    initialValue: t2.initialValue,
     render() {
-      const t2 = e.withGuide ?? settings.withGuide, d = `${symbol(this.state)}  `, s = `${symbolBar(this.state)}  `, n2 = wrapTextWithPrefix(
-        e.output,
-        e.message,
+      const i2 = t2.withGuide ?? settings.withGuide, m = `${symbol(this.state)}  `, s = `${symbolBar(this.state)}  `, n2 = wrapTextWithPrefix(
+        t2.output,
+        t2.message,
         s,
-        d
-      ), u3 = `${t2 ? `${styleText2("gray", S_BAR)}
+        m
+      ), u3 = `${i2 ? `${styleText2("gray", S_BAR)}
 ` : ""}${n2}
 `;
       switch (this.state) {
         case "submit": {
-          const r2 = t2 ? `${styleText2("gray", S_BAR)}  ` : "", l2 = wrapTextWithPrefix(
-            e.output,
+          const r2 = i2 ? `${styleText2("gray", S_BAR)}  ` : "", o2 = wrapTextWithPrefix(
+            t2.output,
             a2(this.options[this.cursor], "selected"),
             r2
           );
-          return `${u3}${l2}`;
+          return `${u3}${o2}`;
         }
         case "cancel": {
-          const r2 = t2 ? `${styleText2("gray", S_BAR)}  ` : "", l2 = wrapTextWithPrefix(
-            e.output,
+          const r2 = i2 ? `${styleText2("gray", S_BAR)}  ` : "", o2 = wrapTextWithPrefix(
+            t2.output,
             a2(this.options[this.cursor], "cancelled"),
             r2
           );
-          return `${u3}${l2}${t2 ? `
+          return `${u3}${o2}${i2 ? `
 ${styleText2("gray", S_BAR)}` : ""}`;
         }
         default: {
-          const r2 = t2 ? `${styleText2("cyan", S_BAR)}  ` : "", l2 = t2 ? styleText2("cyan", S_BAR_END) : "", g = u3.split(`
-`).length, h2 = t2 ? 2 : 1;
+          const r2 = i2 ? `${styleText2("cyan", S_BAR)}  ` : "", o2 = u3.split(`
+`).length, $ = formatInstructionFooter(SELECT_INSTRUCTIONS, i2), h2 = $.join(`
+`), b = $.length + 1;
           return `${u3}${r2}${limitOptions({
-            output: e.output,
+            output: t2.output,
             cursor: this.cursor,
             options: this.options,
-            maxItems: e.maxItems,
+            maxItems: t2.maxItems,
             columnPadding: r2.length,
-            rowPadding: g + h2,
-            style: (p, b) => a2(p, p.disabled ? "disabled" : b ? "active" : "inactive")
+            rowPadding: o2 + b,
+            style: (p, x) => a2(p, p.disabled ? "disabled" : x ? "active" : "inactive")
           }).join(`
 ${r2}`)}
-${l2}
+${h2}
 `;
         }
       }
@@ -9457,6 +9733,8 @@ async function preflightHealth(url, token) {
       signal: controller.signal,
       headers: token ? { Authorization: `Bearer ${token}` } : {}
     });
+    await res.body?.cancel().catch(() => {
+    });
     if (!res.ok) {
       const hint = res.status === 401 ? " \u2014 the server requires a token; pass --token or use the argent:// link from `server start`" : res.status === 403 ? " \u2014 the server refused this host (DNS-rebinding guard); reach it by its bind host or start it with --host" : "";
       return { ok: false, error: `${res.status} ${res.statusText}${hint}` };
@@ -9719,7 +9997,7 @@ function printStatus() {
   console.log(`  anon id: ${anonLabel}`);
 }
 async function cmdEnable() {
-  const wasEnabled = isEnabled2();
+  const wasEnabled = isEnabled();
   markEnabled();
   if (wasEnabled) {
     console.log(import_picocolors3.default.dim("Telemetry was already enabled."));
@@ -9729,7 +10007,7 @@ async function cmdEnable() {
   await shutdown();
 }
 async function cmdDisable() {
-  const wasEnabled = isEnabled2();
+  const wasEnabled = isEnabled();
   if (!wasEnabled) {
     console.log(import_picocolors3.default.dim("Telemetry was already disabled."));
     await shutdown();