oh-my-opencode 5.0.0-beta.3 → 5.0.0-beta.30

package/packages/omo-codex/scripts/install-dist/install-local.mjs

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-// omo-codex-install:7bc4b0f020f0a1b4448cc75385a7e3c60042e3b270e304d4c1a43a859e81a4c2:83a9041418efce98ae46a8f3601b363e3e6c9f6bc17b39665cb73cb77bc99833
+// omo-codex-install:819e258f7485f9ccdcbb64a54ac0097bf81cd8e2980d7f907017f224b1f99b98:e19da597bc0859c4e499399c6f394680812dba1e8cc6d69a408177a8def55fd7
 var __defProp = Object.defineProperty;
 var __returnValue = (v) => v;
 function __exportSetter(name, newValue) {
@@ -47,9 +47,12 @@ import {
   fsyncSync,
   openSync,
   renameSync,
+  rmSync,
   unlinkSync,
   writeFileSync
 } from "node:fs";
+import { randomUUID } from "node:crypto";
+import { dirname as dirname10 } from "node:path";
 function isToleratedFsyncError(error) {
   if (!(error instanceof Error))
     return false;
@@ -65,24 +68,36 @@ function tolerantFsyncSync(fileDescriptor, fsyncImpl) {
   }
 }
 function writeFileAtomically(filePath, content, options = {}) {
-  const tempPath = `${filePath}.tmp`;
-  writeFileSync(tempPath, content, "utf-8");
-  const tempFileDescriptor = openSync(tempPath, "r+");
-  try {
-    tolerantFsyncSync(tempFileDescriptor, options.fsyncSync ?? fsyncSync);
-  } finally {
-    closeSync(tempFileDescriptor);
-  }
+  const platform = options.platform ?? process.platform;
+  const fsyncImpl = options.fsyncSync ?? fsyncSync;
+  const tempPath = `${filePath}.${process.pid}.${randomUUID()}.tmp`;
   try {
-    renameSync(tempPath, filePath);
-  } catch (error) {
-    const isPermissionError = error instanceof Error && (error.message.includes("EPERM") || error.message.includes("EACCES"));
-    if ((options.platform ?? process.platform) === "win32" && isPermissionError) {
+    writeFileSync(tempPath, content, "utf-8");
+    const tempFileDescriptor = openSync(tempPath, "r+");
+    try {
+      tolerantFsyncSync(tempFileDescriptor, fsyncImpl);
+    } finally {
+      closeSync(tempFileDescriptor);
+    }
+    try {
+      renameSync(tempPath, filePath);
+    } catch (error) {
+      const isPermissionError = error instanceof Error && (error.message.includes("EPERM") || error.message.includes("EACCES"));
+      if (platform !== "win32" || !isPermissionError)
+        throw error;
       unlinkSync(filePath);
       renameSync(tempPath, filePath);
+    }
+    if (platform === "win32")
       return;
+    const directoryFileDescriptor = openSync(dirname10(filePath), "r");
+    try {
+      tolerantFsyncSync(directoryFileDescriptor, fsyncImpl);
+    } finally {
+      closeSync(directoryFileDescriptor);
     }
-    throw error;
+  } finally {
+    rmSync(tempPath, { force: true });
   }
 }
 var TOLERATED_FSYNC_CODES;
@@ -177,7 +192,7 @@ var init_activity_state = __esm(() => {
 });
 
 // packages/telemetry-core/src/constants.ts
-var DEFAULT_POSTHOG_HOST = "https://us.i.posthog.com", DEFAULT_POSTHOG_API_KEY = "phc_CFJhj5HyvA62QPhvyaUCtaq23aUfznnijg5VaaGkNk74";
+var DEFAULT_POSTHOG_HOST = "https://us.i.posthog.com", DEFAULT_POSTHOG_API_KEY = "phc_CFJhj5HyvA62QPhvyaUCtaq23aUfznnijg5VaaGkNk74", UNCONFIGURED_POSTHOG_API_KEY = "phc_REPLACE_ME_OMO_NATIVE";
 
 // packages/telemetry-core/src/diagnostics.ts
 import { appendFileSync, existsSync as existsSync6, mkdirSync as mkdirSync3, readFileSync as readFileSync3 } from "node:fs";
@@ -315,6 +330,9 @@ function shouldDisableTelemetry(input) {
   const env = input.env ?? process.env;
   const globalPrefix = input.globalEnvPrefix ?? "OMO";
   const prefixes = Array.from(new Set([globalPrefix, input.productEnvPrefix]));
+  if (isDisableFlag(env["DO_NOT_TRACK"])) {
+    return true;
+  }
   for (const prefix of prefixes) {
     if (isDisableFlag(env[`${prefix}_DISABLE_POSTHOG`])) {
       return true;
@@ -328,6 +346,13 @@ function shouldDisableTelemetry(input) {
 function getTelemetryApiKey(env = process.env, defaultApiKey = DEFAULT_POSTHOG_API_KEY) {
   return env["POSTHOG_API_KEY"]?.trim() ?? defaultApiKey;
 }
+function isConfiguredTelemetryApiKey(apiKey) {
+  const normalized = apiKey.trim();
+  return normalized.length > 0 && normalized !== UNCONFIGURED_POSTHOG_API_KEY;
+}
+function hasTelemetryApiKey(env, defaultApiKey) {
+  return isConfiguredTelemetryApiKey(getTelemetryApiKey(env, defaultApiKey));
+}
 function getTelemetryHost(env = process.env, defaultHost = DEFAULT_POSTHOG_HOST) {
   return env["POSTHOG_HOST"]?.trim() || defaultHost;
 }
@@ -337,19 +362,8 @@ var init_env = __esm(() => {
   SEND_OPT_OUT_VALUES = ["0", "false", "no", "yes"];
 });
 
-// packages/telemetry-core/src/machine-id.ts
-import { createHash as createHash3 } from "node:crypto";
-import os2 from "node:os";
-function getDefaultTelemetryOsProvider() {
-  return os2;
-}
-function getTelemetryDistinctId(machineIdPrefix, osProvider = getDefaultTelemetryOsProvider()) {
-  return createHash3("sha256").update(`${machineIdPrefix}${osProvider.hostname()}`).digest("hex");
-}
-var init_machine_id = () => {};
-
-// node_modules/.bun/posthog-node@5.35.12/node_modules/posthog-node/dist/extensions/error-tracking/modifiers/module.node.mjs
-import { dirname as dirname10, posix as posix2, sep as sep7 } from "node:path";
+// node_modules/.bun/posthog-node@5.51.1/node_modules/posthog-node/dist/extensions/error-tracking/modifiers/module.node.mjs
+import { dirname as dirname11, posix as posix2, sep as sep7 } from "node:path";
 function createModulerModifier() {
   const getModuleFromFileName = createGetModuleFromFilename();
   return async (frames) => {
@@ -358,7 +372,7 @@ function createModulerModifier() {
     return frames;
   };
 }
-function createGetModuleFromFilename(basePath = process.argv[1] ? dirname10(process.argv[1]) : process.cwd(), isWindows = sep7 === "\\") {
+function createGetModuleFromFilename(basePath = process.argv[1] ? dirname11(process.argv[1]) : process.cwd(), isWindows = sep7 === "\\") {
   const normalizedBase = isWindows ? normalizeWindowsPath(basePath) : basePath;
   return (filename) => {
     if (!filename)
@@ -385,7 +399,7 @@ function normalizeWindowsPath(path2) {
 }
 var init_module_node = () => {};
 
-// node_modules/.bun/@posthog+core@1.30.3/node_modules/@posthog/core/dist/featureFlagUtils.mjs
+// node_modules/.bun/@posthog+core@1.48.9/node_modules/@posthog/core/dist/featureFlagUtils.mjs
 function getFlagDetailFromFlagAndPayload(key, value, payload) {
   return {
     key,
@@ -450,10 +464,71 @@ var normalizeFlagsResponse = (flagsResponse) => {
   } catch {
     return response;
   }
+}, MINIMAL_FLAG_CALLED_EVENT_CAMPAIGN_PROPERTIES, MINIMAL_FLAG_CALLED_EVENT_PROPERTIES, minimizeFlagCalledEventProperties = (properties, transportKeys = []) => {
+  const minimal = {};
+  const copyKey = (key) => {
+    if (properties[key] !== undefined)
+      minimal[key] = properties[key];
+  };
+  MINIMAL_FLAG_CALLED_EVENT_PROPERTIES.forEach(copyKey);
+  transportKeys.forEach(copyKey);
+  return minimal;
 };
-var init_featureFlagUtils = () => {};
+var init_featureFlagUtils = __esm(() => {
+  MINIMAL_FLAG_CALLED_EVENT_CAMPAIGN_PROPERTIES = [
+    "utm_source",
+    "utm_medium",
+    "utm_campaign",
+    "utm_content",
+    "utm_term",
+    "gad_source",
+    "mc_cid",
+    "gclid",
+    "gclsrc",
+    "dclid",
+    "gbraid",
+    "wbraid",
+    "fbclid",
+    "msclkid",
+    "twclid",
+    "li_fat_id",
+    "igshid",
+    "ttclid",
+    "rdt_cid",
+    "epik",
+    "qclid",
+    "sccid",
+    "irclid",
+    "_kx"
+  ];
+  MINIMAL_FLAG_CALLED_EVENT_PROPERTIES = [
+    "$feature_flag",
+    "$feature_flag_response",
+    "$feature_flag_has_experiment",
+    "$feature_flag_id",
+    "$feature_flag_version",
+    "$feature_flag_reason",
+    "$feature_flag_request_id",
+    "$feature_flag_evaluated_at",
+    "$feature_flag_error",
+    "locally_evaluated",
+    "$groups",
+    "$process_person_profile",
+    "$geoip_disable",
+    "$current_url",
+    "$pathname",
+    "$referring_domain",
+    ...MINIMAL_FLAG_CALLED_EVENT_CAMPAIGN_PROPERTIES,
+    "$session_id",
+    "$window_id",
+    "$lib",
+    "$lib_version",
+    "$device_id",
+    "$is_server"
+  ];
+});
 
-// node_modules/.bun/@posthog+core@1.30.3/node_modules/@posthog/core/dist/types.mjs
+// node_modules/.bun/@posthog+core@1.48.9/node_modules/@posthog/core/dist/types.mjs
 var types_PostHogPersistedProperty;
 var init_types = __esm(() => {
   types_PostHogPersistedProperty = /* @__PURE__ */ function(PostHogPersistedProperty) {
@@ -470,6 +545,8 @@ var init_types = __esm(() => {
     PostHogPersistedProperty["BootstrapFeatureFlagPayloads"] = "bootstrap_feature_flag_payloads";
     PostHogPersistedProperty["OverrideFeatureFlags"] = "override_feature_flags";
     PostHogPersistedProperty["Queue"] = "queue";
+    PostHogPersistedProperty["AiQueue"] = "ai_queue";
+    PostHogPersistedProperty["AiCaptureQueue"] = "ai_capture_queue";
     PostHogPersistedProperty["LogsQueue"] = "logs_queue";
     PostHogPersistedProperty["OptedOut"] = "opted_out";
     PostHogPersistedProperty["SessionId"] = "session_id";
@@ -480,6 +557,8 @@ var init_types = __esm(() => {
     PostHogPersistedProperty["InstalledAppBuild"] = "installed_app_build";
     PostHogPersistedProperty["InstalledAppVersion"] = "installed_app_version";
     PostHogPersistedProperty["SessionReplay"] = "session_replay";
+    PostHogPersistedProperty["PushRegistered"] = "push_registered";
+    PostHogPersistedProperty["SessionReplayEventTriggerActivatedSession"] = "session_replay_event_trigger_activated_session";
     PostHogPersistedProperty["SurveyLastSeenDate"] = "survey_last_seen_date";
     PostHogPersistedProperty["SurveysSeen"] = "surveys_seen";
     PostHogPersistedProperty["Surveys"] = "surveys";
@@ -490,14 +569,14 @@ var init_types = __esm(() => {
   }({});
 });
 
-// node_modules/.bun/@posthog+core@1.30.3/node_modules/@posthog/core/dist/gzip.mjs
+// node_modules/.bun/@posthog+core@1.48.9/node_modules/@posthog/core/dist/gzip.mjs
 function isGzipSupported() {
   return "CompressionStream" in globalThis && "TextEncoder" in globalThis && "Response" in globalThis && typeof Response.prototype.blob == "function";
 }
 async function gzipCompress(input, isDebug = true, options) {
   try {
     const inputBytes = new TextEncoder().encode(input);
-    const compressedStream = new CompressionStream("gzip");
+    const compressedStream = new globalThis.CompressionStream("gzip");
     const writer = compressedStream.writable.getWriter();
     const writePromise = writer.write(inputBytes).then(() => writer.close()).catch(async (err) => {
       try {
@@ -558,7 +637,30 @@ var init_gzip = __esm(() => {
   init_types();
 });
 
-// node_modules/.bun/@posthog+core@1.30.3/node_modules/@posthog/core/dist/utils/bot-detection.mjs
+// node_modules/.bun/@posthog+core@1.48.9/node_modules/@posthog/core/dist/utils/json-utils.mjs
+function sanitizeString(value) {
+  let output = "";
+  for (let index = 0;index < value.length; index++) {
+    const codeUnit = value.charCodeAt(index);
+    if (codeUnit >= 55296 && codeUnit <= 56319) {
+      const nextCodeUnit = value.charCodeAt(index + 1);
+      if (nextCodeUnit >= 56320 && nextCodeUnit <= 57343) {
+        output += value[index] + value[index + 1];
+        index++;
+      } else
+        output += "�";
+    } else
+      output += codeUnit >= 56320 && codeUnit <= 57343 ? "�" : value[index];
+  }
+  return output;
+}
+var MAX_JSON_SAFE_VALUE_DEPTH = 20, MAX_JSON_SAFE_VALUE_ITEMS = 1000, MAX_JSON_SAFE_VALUE_NODES = 1e4, CIRCULAR_VALUE = "[Circular]", TRUNCATED_VALUE = "[Truncated]", UNSERIALIZABLE_VALUE = "[Unserializable]", FUNCTION_VALUE = "[Function]", dateGetTime, dateToISOString;
+var init_json_utils = __esm(() => {
+  dateGetTime = Date.prototype.getTime;
+  dateToISOString = Date.prototype.toISOString;
+});
+
+// node_modules/.bun/@posthog+core@1.48.9/node_modules/@posthog/core/dist/utils/bot-detection.mjs
 var DEFAULT_BLOCKED_UA_STRS, isBlockedUA = function(ua, customBlockedUserAgents = []) {
   if (!ua)
     return false;
@@ -650,16 +752,56 @@ var init_bot_detection = __esm(() => {
   ];
 });
 
-// node_modules/.bun/@posthog+core@1.30.3/node_modules/@posthog/core/dist/utils/string-utils.mjs
+// node_modules/.bun/@posthog+core@1.48.9/node_modules/@posthog/core/dist/utils/string-utils.mjs
+function safeJsonStringify(value) {
+  const ancestors = [];
+  return JSON.stringify(value, function(_key, replacementValue) {
+    if (typeof replacementValue == "bigint")
+      return replacementValue.toString();
+    if (typeof replacementValue == "function" || typeof replacementValue == "symbol")
+      return;
+    if (replacementValue instanceof Error)
+      return {
+        name: replacementValue.name,
+        message: replacementValue.message,
+        stack: replacementValue.stack
+      };
+    if (replacementValue && typeof replacementValue == "object") {
+      while (ancestors.length > 0 && ancestors[ancestors.length - 1] !== this)
+        ancestors.pop();
+      if (ancestors.includes(replacementValue))
+        return "[Circular]";
+      ancestors.push(replacementValue);
+    }
+    return replacementValue;
+  }) ?? "null";
+}
 var init_string_utils = () => {};
 
-// node_modules/.bun/@posthog+core@1.30.3/node_modules/@posthog/core/dist/utils/type-utils.mjs
+// node_modules/.bun/@posthog+core@1.48.9/node_modules/@posthog/core/dist/utils/browser-utils.mjs
+var init_browser_utils = __esm(() => {
+  init_string_utils();
+});
+
+// node_modules/.bun/@posthog+core@1.48.9/node_modules/@posthog/core/dist/utils/type-utils.mjs
 function isPrimitive(value) {
   return value === null || typeof value != "object";
 }
 function isBuiltin(candidate, className) {
   return Object.prototype.toString.call(candidate) === `[object ${className}]`;
 }
+function isError(candidate) {
+  switch (Object.prototype.toString.call(candidate)) {
+    case "[object Error]":
+    case "[object Exception]":
+    case "[object DOMException]":
+    case "[object DOMError]":
+    case "[object WebAssembly.Exception]":
+      return true;
+    default:
+      return isInstanceOf(candidate, Error);
+  }
+}
 function isErrorEvent(event) {
   return isBuiltin(event, "ErrorEvent");
 }
@@ -676,7 +818,7 @@ function isInstanceOf(candidate, base) {
     return false;
   }
 }
-var nativeIsArray, ObjProto, type_utils_hasOwnProperty, type_utils_toString, isArray, isObject = (x) => x === Object(x) && !isArray(x), isUndefined = (x) => x === undefined, isString = (x) => type_utils_toString.call(x) == "[object String]", isEmptyString = (x) => isString(x) && x.trim().length === 0, isNumber = (x) => type_utils_toString.call(x) == "[object Number]" && x === x, isPlainError = (x) => x instanceof Error;
+var nativeIsArray, ObjProto, type_utils_hasOwnProperty, type_utils_toString, isArray, isObject = (x) => x === Object(x) && !isArray(x), isUndefined = (x) => x === undefined, isString = (x) => type_utils_toString.call(x) == "[object String]", isEmptyString = (x) => isString(x) && x.trim().length === 0, isNull = (x) => x === null, isNullish = (x) => isUndefined(x) || isNull(x), isNumber = (x) => type_utils_toString.call(x) == "[object Number]" && x === x, isBoolean = (x) => type_utils_toString.call(x) === "[object Boolean]";
 var init_type_utils = __esm(() => {
   init_types();
   init_string_utils();
@@ -689,7 +831,7 @@ var init_type_utils = __esm(() => {
   };
 });
 
-// node_modules/.bun/@posthog+core@1.30.3/node_modules/@posthog/core/dist/utils/number-utils.mjs
+// node_modules/.bun/@posthog+core@1.48.9/node_modules/@posthog/core/dist/utils/number-utils.mjs
 function clampToRange(value, min, max, logger, fallbackValue) {
   if (min > max) {
     logger.warn("min cannot be greater than max.");
@@ -712,7 +854,14 @@ var init_number_utils = __esm(() => {
   init_type_utils();
 });
 
-// node_modules/.bun/@posthog+core@1.30.3/node_modules/@posthog/core/dist/utils/bucketed-rate-limiter.mjs
+// node_modules/.bun/@posthog+core@1.48.9/node_modules/@posthog/core/dist/utils/bucketed-rate-limiter.mjs
+function resolveExceptionRateLimiterConfig(config = {}) {
+  return {
+    refillRate: config.exceptionRateLimiterRefillRate ?? config.__exceptionRateLimiterRefillRate ?? DEFAULT_EXCEPTION_RATE_LIMITER_REFILL_RATE,
+    bucketSize: config.exceptionRateLimiterBucketSize ?? config.__exceptionRateLimiterBucketSize ?? DEFAULT_EXCEPTION_RATE_LIMITER_BUCKET_SIZE
+  };
+}
+
 class BucketedRateLimiter {
   constructor(options) {
     this._buckets = {};
@@ -754,12 +903,12 @@ class BucketedRateLimiter {
     this._buckets = {};
   }
 }
-var ONE_DAY_IN_MS = 86400000;
+var ONE_DAY_IN_MS = 86400000, DEFAULT_EXCEPTION_RATE_LIMITER_REFILL_RATE = 1, DEFAULT_EXCEPTION_RATE_LIMITER_BUCKET_SIZE = 10;
 var init_bucketed_rate_limiter = __esm(() => {
   init_number_utils();
 });
 
-// node_modules/.bun/@posthog+core@1.30.3/node_modules/@posthog/core/dist/vendor/uuidv7.mjs
+// node_modules/.bun/@posthog+core@1.48.9/node_modules/@posthog/core/dist/vendor/uuidv7.mjs
 class UUID {
   constructor(bytes) {
     this.bytes = bytes;
@@ -934,37 +1083,49 @@ var init_uuidv7 = __esm(() => {
   /*! For license information please see uuidv7.mjs.LICENSE.txt */
 });
 
-// node_modules/.bun/@posthog+core@1.30.3/node_modules/@posthog/core/dist/utils/promise-queue.mjs
+// node_modules/.bun/@posthog+core@1.48.9/node_modules/@posthog/core/dist/utils/promise-queue.mjs
 class PromiseQueue {
   add(promise) {
     const promiseUUID = uuidv7();
-    this.promiseByIds[promiseUUID] = promise;
+    const id = ++this.nextId;
+    this.promiseByIds[promiseUUID] = {
+      id,
+      promise
+    };
     promise.catch(() => {}).finally(() => {
       delete this.promiseByIds[promiseUUID];
     });
     return promise;
   }
   async join() {
-    let promises = Object.values(this.promiseByIds);
+    let promises = Object.values(this.promiseByIds).map((item) => item.promise);
     let length = promises.length;
     while (length > 0) {
       await Promise.all(promises);
-      promises = Object.values(this.promiseByIds);
+      promises = Object.values(this.promiseByIds).map((item) => item.promise);
       length = promises.length;
     }
   }
+  getPromises(ignoredPromises = [], maxId = this.nextId) {
+    const ignoredPromiseSet = new Set(ignoredPromises);
+    return Object.values(this.promiseByIds).filter((item) => item.id <= maxId && !ignoredPromiseSet.has(item.promise)).map((item) => item.promise);
+  }
+  get maxId() {
+    return this.nextId;
+  }
   get length() {
     return Object.keys(this.promiseByIds).length;
   }
   constructor() {
     this.promiseByIds = {};
+    this.nextId = 0;
   }
 }
 var init_promise_queue = __esm(() => {
   init_uuidv7();
 });
 
-// node_modules/.bun/@posthog+core@1.30.3/node_modules/@posthog/core/dist/utils/logger.mjs
+// node_modules/.bun/@posthog+core@1.48.9/node_modules/@posthog/core/dist/utils/logger.mjs
 function createConsole(consoleLike = console) {
   const lockedMethods = {
     log: consoleLike.log.bind(consoleLike),
@@ -1006,8 +1167,8 @@ var _createLogger = (prefix, maybeCall, consoleLike) => {
 }, passThrough = (fn) => fn();
 var init_logger = () => {};
 
-// node_modules/.bun/@posthog+core@1.30.3/node_modules/@posthog/core/dist/utils/user-agent-utils.mjs
-var MOBILE = "Mobile", IOS = "iOS", ANDROID = "Android", TABLET = "Tablet", ANDROID_TABLET, APPLE = "Apple", APPLE_WATCH, SAFARI = "Safari", BLACKBERRY = "BlackBerry", SAMSUNG = "Samsung", SAMSUNG_BROWSER, SAMSUNG_INTERNET, CHROME = "Chrome", CHROME_OS, CHROME_IOS, INTERNET_EXPLORER = "Internet Explorer", INTERNET_EXPLORER_MOBILE, OPERA = "Opera", OPERA_MINI, EDGE = "Edge", MICROSOFT_EDGE, FIREFOX = "Firefox", FIREFOX_IOS, NINTENDO = "Nintendo", PLAYSTATION = "PlayStation", XBOX = "Xbox", ANDROID_MOBILE, MOBILE_SAFARI, WINDOWS = "Windows", WINDOWS_PHONE, GENERIC = "Generic", GENERIC_MOBILE, GENERIC_TABLET, KONQUEROR = "Konqueror", OCULUS_BROWSER = "Oculus Browser", VIVALDI = "Vivaldi", YANDEX = "Yandex", WHALE = "Whale", DUCKDUCKGO = "DuckDuckGo", PALE_MOON = "Pale Moon", WATERFOX = "Waterfox", BRAVE = "Brave", BROWSER_VERSION_REGEX_SUFFIX = "(\\d+(\\.\\d+)?)", DEFAULT_BROWSER_VERSION_REGEX, XBOX_REGEX, PLAYSTATION_REGEX, NINTENDO_REGEX, BLACKBERRY_REGEX, windowsVersionMap, versionRegexes, osMatchers;
+// node_modules/.bun/@posthog+core@1.48.9/node_modules/@posthog/core/dist/utils/user-agent-utils.mjs
+var MOBILE = "Mobile", IOS = "iOS", ANDROID = "Android", TABLET = "Tablet", ANDROID_TABLET, APPLE = "Apple", APPLE_WATCH, SAFARI = "Safari", BLACKBERRY = "BlackBerry", SAMSUNG = "Samsung", SAMSUNG_BROWSER, SAMSUNG_INTERNET, CHROME = "Chrome", CHROME_OS, CHROME_IOS, INTERNET_EXPLORER = "Internet Explorer", INTERNET_EXPLORER_MOBILE, OPERA = "Opera", OPERA_MINI, EDGE = "Edge", MICROSOFT_EDGE, FIREFOX = "Firefox", FIREFOX_IOS, NINTENDO = "Nintendo", PLAYSTATION = "PlayStation", XBOX = "Xbox", ANDROID_MOBILE, MOBILE_SAFARI, WINDOWS = "Windows", WINDOWS_PHONE, GENERIC = "Generic", GENERIC_MOBILE, GENERIC_TABLET, KONQUEROR = "Konqueror", OCULUS_BROWSER = "Oculus Browser", VIVALDI = "Vivaldi", YANDEX = "Yandex", WHALE = "Whale", DUCKDUCKGO = "DuckDuckGo", PALE_MOON = "Pale Moon", WATERFOX = "Waterfox", BRAVE = "Brave", GOOGLE_SEARCH_APP = "Google Search App", BROWSER_VERSION_REGEX_SUFFIX = "(\\d+(\\.\\d+)?)", DEFAULT_BROWSER_VERSION_REGEX, XBOX_REGEX, PLAYSTATION_REGEX, NINTENDO_REGEX, BLACKBERRY_REGEX, windowsVersionMap, versionRegexes, osMatchers;
 var init_user_agent_utils = __esm(() => {
   init_string_utils();
   init_type_utils();
@@ -1112,6 +1273,9 @@ var init_user_agent_utils = __esm(() => {
     [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)
     ],
@@ -1272,7 +1436,13 @@ var init_user_agent_utils = __esm(() => {
   ];
 });
 
-// node_modules/.bun/@posthog+core@1.30.3/node_modules/@posthog/core/dist/utils/index.mjs
+// node_modules/.bun/@posthog+core@1.48.9/node_modules/@posthog/core/dist/utils/index.mjs
+function isValidUUID(value) {
+  return typeof value == "string" && UUID_REGEX.test(value);
+}
+function getEventUuid(uuid, generateUuid) {
+  return isValidUUID(uuid) ? uuid : generateUuid();
+}
 function removeTrailingSlash(url) {
   return url?.replace(/\/+$/, "");
 }
@@ -1300,6 +1470,26 @@ function safeSetTimeout(fn, timeout) {
   t?.unref && t?.unref();
   return t;
 }
+async function raceWithTimeout(promise, timeoutMs, onTimeout) {
+  let timeoutHandle;
+  try {
+    return await Promise.race([
+      promise,
+      new Promise((resolve9, reject) => {
+        timeoutHandle = safeSetTimeout(() => {
+          try {
+            onTimeout?.();
+            resolve9();
+          } catch (error) {
+            reject(error);
+          }
+        }, timeoutMs);
+      })
+    ]);
+  } finally {
+    clearTimeout(timeoutHandle);
+  }
+}
 function allSettled(promises) {
   return Promise.all(promises.map((p) => (p ?? Promise.resolve()).then((value) => ({
     status: "fulfilled",
@@ -1309,9 +1499,11 @@ function allSettled(promises) {
     reason
   }))));
 }
-var STRING_FORMAT = "utf8", isError = (x) => x instanceof Error;
+var STRING_FORMAT = "utf8", UUID_REGEX;
 var init_utils = __esm(() => {
+  init_json_utils();
   init_bot_detection();
+  init_browser_utils();
   init_bucketed_rate_limiter();
   init_number_utils();
   init_string_utils();
@@ -1319,12 +1511,168 @@ var init_utils = __esm(() => {
   init_promise_queue();
   init_logger();
   init_user_agent_utils();
+  UUID_REGEX = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
 });
 
-// node_modules/.bun/@posthog+core@1.30.3/node_modules/@posthog/core/dist/logs/logs-utils.mjs
-var OTLP_SEVERITY_MAP, DEFAULT_OTLP_SEVERITY;
+// node_modules/.bun/@posthog+core@1.48.9/node_modules/@posthog/core/dist/logs/logs-utils.mjs
+function newState() {
+  return {
+    ancestors: new WeakSet,
+    remainingNodes: MAX_JSON_SAFE_VALUE_NODES
+  };
+}
+function toOtlpKeyValueList(attrs, logger2) {
+  try {
+    return encodeKeyValueList(attrs, logger2, newState(), 0);
+  } catch {
+    return [];
+  }
+}
+function encodeAnyValue(value, logger2, state, depth) {
+  if (state.remainingNodes <= 0)
+    return {
+      stringValue: TRUNCATED_VALUE
+    };
+  state.remainingNodes--;
+  if (isBoolean(value))
+    return {
+      boolValue: value
+    };
+  if (typeof value == "number") {
+    if (!Number.isFinite(value))
+      return {
+        stringValue: String(value)
+      };
+    if (Number.isInteger(value)) {
+      if (Number.isSafeInteger(value))
+        return {
+          intValue: String(value)
+        };
+      if (typeof BigInt == "undefined")
+        return {
+          stringValue: String(value)
+        };
+      const decimal = BigInt(value).toString();
+      if (value >= INT64_RANGE_LIMIT || value < -INT64_RANGE_LIMIT) {
+        logger2?.debug(`Attribute ${decimal} is outside the int64 range; encoding it as a string`);
+        return {
+          stringValue: decimal
+        };
+      }
+      return {
+        intValue: decimal
+      };
+    }
+    return {
+      doubleValue: value
+    };
+  }
+  if (typeof value == "string")
+    return {
+      stringValue: sanitizeString(value)
+    };
+  if (typeof value == "function")
+    return {
+      stringValue: FUNCTION_VALUE
+    };
+  if (typeof value == "symbol")
+    return {
+      stringValue: String(value)
+    };
+  if (typeof value == "object" && value !== null) {
+    if (state.ancestors.has(value))
+      return {
+        stringValue: CIRCULAR_VALUE
+      };
+    if (depth >= MAX_JSON_SAFE_VALUE_DEPTH)
+      return {
+        stringValue: TRUNCATED_VALUE
+      };
+    if (value instanceof Date) {
+      const time = value.getTime();
+      const iso = Number.isFinite(time) ? value.toISOString() : String(value);
+      return {
+        stringValue: typeof iso == "string" ? sanitizeString(iso) : String(iso)
+      };
+    }
+    state.ancestors.add(value);
+    try {
+      try {
+        const toJSON = value.toJSON;
+        if (typeof toJSON == "function")
+          return encodeAnyValue(toJSON.call(value), logger2, state, depth + 1);
+      } catch {}
+      if (isArray(value))
+        return {
+          arrayValue: {
+            values: encodeArrayValues(value, logger2, state, depth + 1)
+          }
+        };
+      return {
+        kvlistValue: {
+          values: encodeKeyValueList(value, logger2, state, depth + 1)
+        }
+      };
+    } finally {
+      state.ancestors.delete(value);
+    }
+  }
+  return {
+    stringValue: sanitizeString(String(value))
+  };
+}
+function encodeArrayValues(values, logger2, state, depth) {
+  const result = [];
+  const itemCount = Math.min(values.length, MAX_JSON_SAFE_VALUE_ITEMS);
+  let index = 0;
+  for (;index < itemCount && state.remainingNodes > 0; index++)
+    try {
+      const element = index in values ? values[index] : undefined;
+      if (isNullish(element))
+        continue;
+      result.push(encodeAnyValue(element, logger2, state, depth));
+    } catch {
+      result.push({
+        stringValue: UNSERIALIZABLE_VALUE
+      });
+    }
+  if (values.length > index)
+    result.push({
+      stringValue: TRUNCATED_VALUE
+    });
+  return result;
+}
+function encodeKeyValueList(attrs, logger2, state, depth) {
+  const result = [];
+  for (const key in attrs)
+    if (propertyIsEnumerable.call(attrs, key)) {
+      if (result.length >= MAX_JSON_SAFE_VALUE_ITEMS || state.remainingNodes <= 0) {
+        logger2?.debug("Attributes truncated: the value exceeds the OTLP encoder budget");
+        break;
+      }
+      try {
+        const value = attrs[key];
+        if (isNull(value) || isUndefined(value))
+          continue;
+        result.push({
+          key: sanitizeString(key),
+          value: encodeAnyValue(value, logger2, state, depth)
+        });
+      } catch {
+        result.push({
+          key: sanitizeString(key),
+          value: {
+            stringValue: UNSERIALIZABLE_VALUE
+          }
+        });
+      }
+    }
+  return result;
+}
+var OTLP_SEVERITY_MAP, DEFAULT_OTLP_SEVERITY, INT64_RANGE_LIMIT = 9223372036854776000, propertyIsEnumerable;
 var init_logs_utils = __esm(() => {
   init_utils();
+  init_json_utils();
   OTLP_SEVERITY_MAP = {
     trace: {
       text: "TRACE",
@@ -1352,27 +1700,444 @@ var init_logs_utils = __esm(() => {
     }
   };
   DEFAULT_OTLP_SEVERITY = OTLP_SEVERITY_MAP.info;
+  propertyIsEnumerable = Object.prototype.propertyIsEnumerable;
 });
 
-// node_modules/.bun/@posthog+core@1.30.3/node_modules/@posthog/core/dist/logs/index.mjs
+// node_modules/.bun/@posthog+core@1.48.9/node_modules/@posthog/core/dist/logs/index.mjs
 var init_logs = __esm(() => {
   init_logs_utils();
   init_types();
   init_utils();
 });
 
-// node_modules/.bun/@posthog+core@1.30.3/node_modules/@posthog/core/dist/surveys/validation.mjs
+// node_modules/.bun/@posthog+core@1.48.9/node_modules/@posthog/core/dist/metrics/metrics-utils.mjs
+function msToUnixNano(ms) {
+  return String(ms) + "000000";
+}
+function seriesKey(type, name, unit, attributes) {
+  let attrsKey = "";
+  if (attributes) {
+    const keys = Object.keys(attributes).sort();
+    attrsKey = keys.map((k) => `${JSON.stringify(k)}:${JSON.stringify(attributes[k])}`).join(",");
+  }
+  return `${type}\x00${name}\x00${unit ?? ""}\x00${attrsKey}`;
+}
+function bucketIndexFor(value, bounds) {
+  for (let i = 0;i < bounds.length; i++)
+    if (value <= bounds[i])
+      return i;
+  return bounds.length;
+}
+function buildMetricsResourceAttributes(config, scopeName, scopeVersion) {
+  return {
+    ...config.resourceAttributes,
+    "service.name": config.serviceName || "unknown_service",
+    ...config.environment && {
+      "deployment.environment": config.environment
+    },
+    ...config.serviceVersion && {
+      "service.version": config.serviceVersion
+    },
+    "telemetry.sdk.name": scopeName,
+    "telemetry.sdk.version": scopeVersion
+  };
+}
+function buildOtlpMetricsPayload(metrics, resourceAttributes, scopeName, scopeVersion) {
+  return {
+    resourceMetrics: [
+      {
+        resource: {
+          attributes: toOtlpKeyValueList(resourceAttributes)
+        },
+        scopeMetrics: [
+          {
+            scope: {
+              name: scopeName,
+              version: scopeVersion
+            },
+            metrics
+          }
+        ]
+      }
+    ]
+  };
+}
+var DEFAULT_HISTOGRAM_BOUNDS;
+var init_metrics_utils = __esm(() => {
+  init_logs_utils();
+  DEFAULT_HISTOGRAM_BOUNDS = [
+    0,
+    5,
+    10,
+    25,
+    50,
+    75,
+    100,
+    250,
+    500,
+    750,
+    1000,
+    2500,
+    5000,
+    7500,
+    1e4
+  ];
+});
+
+// node_modules/.bun/@posthog+core@1.48.9/node_modules/@posthog/core/dist/metrics/config.mjs
+function resolveMetricsConfig(config) {
+  const resourceAttributes = config?.resourceAttributes;
+  return {
+    serviceName: resourceAttributes?.["service.name"] ?? config?.serviceName,
+    serviceVersion: resourceAttributes?.["service.version"] ?? config?.serviceVersion,
+    environment: resourceAttributes?.["deployment.environment"] ?? config?.environment,
+    resourceAttributes,
+    beforeSend: config?.beforeSend,
+    flushIntervalMs: config?.flushIntervalMs ?? DEFAULT_FLUSH_INTERVAL_MS,
+    maxSeriesPerFlush: config?.maxSeriesPerFlush ?? DEFAULT_MAX_SERIES_PER_FLUSH
+  };
+}
+var DEFAULT_FLUSH_INTERVAL_MS = 1e4, DEFAULT_MAX_SERIES_PER_FLUSH = 1000;
+var init_config = () => {};
+
+// node_modules/.bun/@posthog+core@1.48.9/node_modules/@posthog/core/dist/metrics/index.mjs
+class PostHogMetrics {
+  constructor(_instance, _config, _logger) {
+    this._instance = _instance;
+    this._config = _config;
+    this._logger = _logger;
+    this._series = new Map;
+    this._flushPromise = null;
+    this._seriesCapWarned = false;
+    this._typeByName = new Map;
+    this._typeCollisionWarned = new Set;
+    this._generation = 0;
+  }
+  count(name, value = 1, options) {
+    this._capture({
+      name,
+      type: "count",
+      value,
+      unit: options?.unit,
+      attributes: options?.attributes
+    });
+  }
+  gauge(name, value, options) {
+    this._capture({
+      name,
+      type: "gauge",
+      value,
+      unit: options?.unit,
+      attributes: options?.attributes
+    });
+  }
+  histogram(name, value, options) {
+    this._capture({
+      name,
+      type: "histogram",
+      value,
+      unit: options?.unit,
+      attributes: options?.attributes
+    });
+  }
+  flush() {
+    const prev = this._flushPromise;
+    const run = async () => {
+      if (prev)
+        await prev.catch(() => {});
+      await this._doFlush();
+    };
+    const p = run().finally(() => {
+      if (this._flushPromise === p)
+        this._flushPromise = null;
+    });
+    this._flushPromise = p;
+    return p;
+  }
+  drainWindow() {
+    if (this._series.size === 0)
+      return null;
+    const window = this._series;
+    this._series = new Map;
+    this._seriesCapWarned = false;
+    this._typeByName = new Map;
+    this._typeCollisionWarned = new Set;
+    return this._buildPayload(window);
+  }
+  reset() {
+    this._generation++;
+    this._clearFlushTimer();
+    this._series = new Map;
+    this._flushPromise = null;
+    this._seriesCapWarned = false;
+    this._typeByName = new Map;
+    this._typeCollisionWarned = new Set;
+  }
+  _capture(sample) {
+    if (this._instance.isDisabled || this._instance.optedOut)
+      return;
+    const filtered = this._runBeforeSend(sample);
+    if (filtered === null)
+      return;
+    if (!filtered.name || typeof filtered.name != "string")
+      return void this._logger.warn("Dropping metric with empty name");
+    if (typeof filtered.value != "number" || !Number.isFinite(filtered.value))
+      return void this._logger.warn(`Dropping metric '${filtered.name}': value must be a finite number`);
+    if (filtered.type === "count" && filtered.value < 0)
+      return void this._logger.warn(`Dropping count '${filtered.name}': counters are monotonic, value must be >= 0`);
+    let attributes;
+    let key;
+    try {
+      attributes = filtered.attributes ? {
+        ...filtered.attributes
+      } : undefined;
+      key = seriesKey(filtered.type, filtered.name, filtered.unit, attributes);
+    } catch (e) {
+      this._logger.warn(`Dropping metric '${filtered.name}': attributes could not be serialized`, e);
+      return;
+    }
+    let state = this._series.get(key);
+    if (!state) {
+      if (!this._admitNewSeries())
+        return;
+      state = {
+        name: filtered.name,
+        type: filtered.type,
+        unit: filtered.unit,
+        attributes,
+        windowStartMs: Date.now()
+      };
+      this._series.set(key, state);
+    }
+    const seenType = this._typeByName.get(filtered.name);
+    if (seenType === undefined)
+      this._typeByName.set(filtered.name, filtered.type);
+    else if (seenType !== filtered.type && !this._typeCollisionWarned.has(filtered.name)) {
+      this._typeCollisionWarned.add(filtered.name);
+      this._logger.warn(`Metric name '${filtered.name}' is already used as a ${seenType}; recording it as a ${filtered.type} too will blend both series in charts. Use a distinct name.`);
+    }
+    this._fold(state, filtered.value);
+    this._armFlushTimer();
+  }
+  _admitNewSeries() {
+    if (this._series.size < this._config.maxSeriesPerFlush)
+      return true;
+    if (!this._seriesCapWarned) {
+      this._seriesCapWarned = true;
+      this._logger.warn(`Metric series cap reached (${this._config.maxSeriesPerFlush} per flush window); dropping new series until the next flush. Reduce attribute cardinality.`);
+    }
+    return false;
+  }
+  _fold(state, value) {
+    switch (state.type) {
+      case "count":
+        state.total = (state.total ?? 0) + value;
+        break;
+      case "gauge":
+        state.last = value;
+        break;
+      case "histogram": {
+        if (!state.hist)
+          state.hist = {
+            count: 0,
+            sum: 0,
+            min: value,
+            max: value,
+            bucketCounts: new Array(DEFAULT_HISTOGRAM_BOUNDS.length + 1).fill(0)
+          };
+        const hist = state.hist;
+        hist.count += 1;
+        hist.sum += value;
+        hist.min = Math.min(hist.min, value);
+        hist.max = Math.max(hist.max, value);
+        hist.bucketCounts[bucketIndexFor(value, DEFAULT_HISTOGRAM_BOUNDS)] += 1;
+        break;
+      }
+    }
+  }
+  _runBeforeSend(sample) {
+    const beforeSend = this._config.beforeSend;
+    if (!beforeSend)
+      return sample;
+    const fns = isArray(beforeSend) ? beforeSend : [
+      beforeSend
+    ];
+    let result = sample;
+    for (const fn of fns)
+      try {
+        const next = fn(result);
+        if (!next) {
+          this._logger.info("Metric was rejected in beforeSend function");
+          return null;
+        }
+        result = next;
+      } catch (e) {
+        this._logger.error("Error in beforeSend function for metric:", e);
+        return null;
+      }
+    return result;
+  }
+  _armFlushTimer() {
+    if (this._flushTimer)
+      return;
+    this._flushTimer = safeSetTimeout(() => {
+      this._flushTimer = undefined;
+      this.flush().catch((e) => {
+        this._logger.error("Metrics flush failed:", e);
+      });
+    }, this._config.flushIntervalMs);
+  }
+  _clearFlushTimer() {
+    if (this._flushTimer) {
+      clearTimeout(this._flushTimer);
+      this._flushTimer = undefined;
+    }
+  }
+  async _doFlush() {
+    if (this._series.size === 0)
+      return;
+    const window = this._series;
+    this._series = new Map;
+    this._seriesCapWarned = false;
+    this._typeByName = new Map;
+    this._typeCollisionWarned = new Set;
+    const generation = this._generation;
+    const outcome = await this._instance._sendMetricsBatch(this._buildPayload(window));
+    if (generation !== this._generation)
+      return;
+    switch (outcome.kind) {
+      case "ok":
+        return;
+      case "retry-later":
+        this._mergeWindowBack(window);
+        this._armFlushTimer();
+        return;
+      case "too-large":
+        this._logger.warn("Metrics batch exceeded the server size limit and was dropped");
+        return;
+      case "fatal":
+        this._logger.error("Failed to send metrics batch:", outcome.error);
+        return;
+    }
+  }
+  _buildPayload(window) {
+    return buildOtlpMetricsPayload(this._buildMetrics(window), buildMetricsResourceAttributes(this._config, this._instance.getLibraryId(), this._instance.getLibraryVersion()), this._instance.getLibraryId(), this._instance.getLibraryVersion());
+  }
+  _buildMetrics(window) {
+    const nowNano = msToUnixNano(Date.now());
+    const byMetric = new Map;
+    for (const state of window.values()) {
+      const metricKey = seriesKey(state.type, state.name, state.unit, undefined);
+      let metric = byMetric.get(metricKey);
+      if (!metric) {
+        metric = {
+          name: state.name,
+          ...state.unit && {
+            unit: state.unit
+          }
+        };
+        if (state.type === "count")
+          metric.sum = {
+            aggregationTemporality: OTLP_TEMPORALITY_DELTA,
+            isMonotonic: true,
+            dataPoints: []
+          };
+        else if (state.type === "gauge")
+          metric.gauge = {
+            dataPoints: []
+          };
+        else
+          metric.histogram = {
+            aggregationTemporality: OTLP_TEMPORALITY_DELTA,
+            dataPoints: []
+          };
+        byMetric.set(metricKey, metric);
+      }
+      const attributes = toOtlpKeyValueList(state.attributes ?? {}, this._logger);
+      const startNano = msToUnixNano(state.windowStartMs);
+      if (state.type === "count") {
+        const dp = {
+          attributes,
+          startTimeUnixNano: startNano,
+          timeUnixNano: nowNano,
+          asDouble: state.total ?? 0
+        };
+        metric.sum.dataPoints.push(dp);
+      } else if (state.type === "gauge") {
+        const dp = {
+          attributes,
+          timeUnixNano: nowNano,
+          asDouble: state.last ?? 0
+        };
+        metric.gauge.dataPoints.push(dp);
+      } else if (state.hist) {
+        const dp = {
+          attributes,
+          startTimeUnixNano: startNano,
+          timeUnixNano: nowNano,
+          count: state.hist.count,
+          sum: state.hist.sum,
+          min: state.hist.min,
+          max: state.hist.max,
+          bucketCounts: state.hist.bucketCounts,
+          explicitBounds: DEFAULT_HISTOGRAM_BOUNDS
+        };
+        metric.histogram.dataPoints.push(dp);
+      }
+    }
+    return Array.from(byMetric.values());
+  }
+  _mergeWindowBack(window) {
+    for (const [key, old] of window) {
+      const current = this._series.get(key);
+      if (!current) {
+        if (this._admitNewSeries())
+          this._series.set(key, old);
+        continue;
+      }
+      current.windowStartMs = Math.min(current.windowStartMs, old.windowStartMs);
+      switch (current.type) {
+        case "count":
+          current.total = (current.total ?? 0) + (old.total ?? 0);
+          break;
+        case "gauge":
+          break;
+        case "histogram":
+          if (old.hist)
+            if (current.hist) {
+              current.hist.count += old.hist.count;
+              current.hist.sum += old.hist.sum;
+              current.hist.min = Math.min(current.hist.min, old.hist.min);
+              current.hist.max = Math.max(current.hist.max, old.hist.max);
+              for (let i = 0;i < current.hist.bucketCounts.length; i++)
+                current.hist.bucketCounts[i] += old.hist.bucketCounts[i];
+            } else
+              current.hist = old.hist;
+          break;
+      }
+    }
+  }
+}
+var OTLP_TEMPORALITY_DELTA = 1;
+var init_metrics = __esm(() => {
+  init_utils();
+  init_logs_utils();
+  init_metrics_utils();
+  init_config();
+});
+
+// node_modules/.bun/@posthog+core@1.48.9/node_modules/@posthog/core/dist/surveys/validation.mjs
 var init_validation = __esm(() => {
   init_types();
 });
 
-// node_modules/.bun/@posthog+core@1.30.3/node_modules/@posthog/core/dist/cookie.mjs
+// node_modules/.bun/@posthog+core@1.48.9/node_modules/@posthog/core/dist/cookie.mjs
 var init_cookie = __esm(() => {
   init_utils();
   init_uuidv7();
 });
 
-// node_modules/.bun/@posthog+core@1.30.3/node_modules/@posthog/core/dist/eventemitter.mjs
+// node_modules/.bun/@posthog+core@1.48.9/node_modules/@posthog/core/dist/eventemitter.mjs
 class SimpleEventEmitter {
   constructor() {
     this.events = {};
@@ -1395,7 +2160,7 @@ class SimpleEventEmitter {
 }
 var init_eventemitter = () => {};
 
-// node_modules/.bun/@posthog+core@1.30.3/node_modules/@posthog/core/dist/error-tracking/chunk-ids.mjs
+// node_modules/.bun/@posthog+core@1.48.9/node_modules/@posthog/core/dist/error-tracking/chunk-ids.mjs
 function getFilenameToChunkIdMap(stackParser) {
   const chunkIdMap = globalThis._posthogChunkIds;
   if (!chunkIdMap)
@@ -1433,7 +2198,7 @@ function getFilenameToChunkIdMap(stackParser) {
 var parsedStackResults, lastKeysCount, cachedFilenameChunkIds;
 var init_chunk_ids = () => {};
 
-// node_modules/.bun/@posthog+core@1.30.3/node_modules/@posthog/core/dist/error-tracking/error-properties-builder.mjs
+// node_modules/.bun/@posthog+core@1.48.9/node_modules/@posthog/core/dist/error-tracking/error-properties-builder.mjs
 class ErrorPropertiesBuilder {
   constructor(coercers, stackParser, modifiers = []) {
     this.coercers = coercers;
@@ -1559,13 +2324,13 @@ var init_error_properties_builder = __esm(() => {
   init_chunk_ids();
 });
 
-// node_modules/.bun/@posthog+core@1.30.3/node_modules/@posthog/core/dist/error-tracking/parsers/base.mjs
+// node_modules/.bun/@posthog+core@1.48.9/node_modules/@posthog/core/dist/error-tracking/parsers/base.mjs
 function createFrame(platform, filename, func, lineno, colno) {
   const frame = {
     platform,
     filename,
     function: func === "<anonymous>" ? UNKNOWN_FUNCTION : func,
-    in_app: true
+    in_app: !filename?.startsWith(MASKED_URL_PREFIX) && filename !== ANONYMOUS_FILENAME
   };
   if (!isUndefined(lineno))
     frame.lineno = lineno;
@@ -1573,12 +2338,12 @@ function createFrame(platform, filename, func, lineno, colno) {
     frame.colno = colno;
   return frame;
 }
-var UNKNOWN_FUNCTION = "?";
+var UNKNOWN_FUNCTION = "?", MASKED_URL_PREFIX = "webkit-masked-url://", ANONYMOUS_FILENAME = "<anonymous>";
 var init_base = __esm(() => {
   init_utils();
 });
 
-// node_modules/.bun/@posthog+core@1.30.3/node_modules/@posthog/core/dist/error-tracking/parsers/safari.mjs
+// node_modules/.bun/@posthog+core@1.48.9/node_modules/@posthog/core/dist/error-tracking/parsers/safari.mjs
 var extractSafariExtensionDetails = (func, filename) => {
   const isSafariExtension = func.indexOf("safari-extension") !== -1;
   const isSafariWebExtension = func.indexOf("safari-web-extension") !== -1;
@@ -1594,7 +2359,7 @@ var init_safari = __esm(() => {
   init_base();
 });
 
-// node_modules/.bun/@posthog+core@1.30.3/node_modules/@posthog/core/dist/error-tracking/parsers/chrome.mjs
+// node_modules/.bun/@posthog+core@1.48.9/node_modules/@posthog/core/dist/error-tracking/parsers/chrome.mjs
 var chromeRegexNoFnName, chromeRegex, chromeEvalRegex, chromeStackLineParser = (line, platform) => {
   const noFnParts = chromeRegexNoFnName.exec(line);
   if (noFnParts) {
@@ -1624,7 +2389,7 @@ var init_chrome = __esm(() => {
   chromeEvalRegex = /\((\S*)(?::(\d+))(?::(\d+))\)/;
 });
 
-// node_modules/.bun/@posthog+core@1.30.3/node_modules/@posthog/core/dist/error-tracking/parsers/gecko.mjs
+// node_modules/.bun/@posthog+core@1.48.9/node_modules/@posthog/core/dist/error-tracking/parsers/gecko.mjs
 var geckoREgex, geckoEvalRegex, geckoStackLineParser = (line, platform) => {
   const parts = geckoREgex.exec(line);
   if (parts) {
@@ -1651,7 +2416,7 @@ var init_gecko = __esm(() => {
   geckoEvalRegex = /(\S+) line (\d+)(?: > eval line \d+)* > eval/i;
 });
 
-// node_modules/.bun/@posthog+core@1.30.3/node_modules/@posthog/core/dist/error-tracking/parsers/winjs.mjs
+// node_modules/.bun/@posthog+core@1.48.9/node_modules/@posthog/core/dist/error-tracking/parsers/winjs.mjs
 var winjsRegex, winjsStackLineParser = (line, platform) => {
   const parts = winjsRegex.exec(line);
   return parts ? createFrame(platform, parts[2], parts[1] || UNKNOWN_FUNCTION, +parts[3], parts[4] ? +parts[4] : undefined) : undefined;
@@ -1661,7 +2426,7 @@ var init_winjs = __esm(() => {
   winjsRegex = /^\s*at (?:((?:\[object object\])?.+) )?\(?((?:[-a-z]+):.*?):(\d+)(?::(\d+))?\)?\s*$/i;
 });
 
-// node_modules/.bun/@posthog+core@1.30.3/node_modules/@posthog/core/dist/error-tracking/parsers/opera.mjs
+// node_modules/.bun/@posthog+core@1.48.9/node_modules/@posthog/core/dist/error-tracking/parsers/opera.mjs
 var opera10Regex, opera10StackLineParser = (line, platform) => {
   const parts = opera10Regex.exec(line);
   return parts ? createFrame(platform, parts[2], parts[3] || UNKNOWN_FUNCTION, +parts[1]) : undefined;
@@ -1675,7 +2440,7 @@ var init_opera = __esm(() => {
   opera11Regex = / line (\d+), column (\d+)\s*(?:in (?:<anonymous function: ([^>]+)>|([^)]+))\(.*\))? in (.*):\s*$/i;
 });
 
-// node_modules/.bun/@posthog+core@1.30.3/node_modules/@posthog/core/dist/error-tracking/parsers/node.mjs
+// node_modules/.bun/@posthog+core@1.48.9/node_modules/@posthog/core/dist/error-tracking/parsers/node.mjs
 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 && filename !== undefined && !filename.includes("node_modules/");
@@ -1683,7 +2448,7 @@ function filenameIsInApp(filename, isNative = false) {
 function _parseIntOrUndefined(input) {
   return parseInt(input || "", 10) || undefined;
 }
-var FILENAME_MATCH, FULL_MATCH, nodeStackLineParser = (line, platform) => {
+var FILENAME_MATCH, FULL_MATCH, PROMISE_COMBINATOR, PROMISE_INDEX, PROMISE_FRAME_FILENAME = "node:internal/promise", nodeStackLineParser = (line, platform) => {
   const lineMatch = line.match(FULL_MATCH);
   if (lineMatch) {
     let object;
@@ -1725,6 +2490,8 @@ var FILENAME_MATCH, FULL_MATCH, nodeStackLineParser = (line, platform) => {
       filename = filename.slice(1);
     if (!filename && lineMatch[5] && !isNative)
       filename = lineMatch[5];
+    if (PROMISE_COMBINATOR.test(functionName) && PROMISE_INDEX.test(filename || ""))
+      filename = PROMISE_FRAME_FILENAME;
     return {
       filename: filename ? decodeURI(filename) : undefined,
       module: undefined,
@@ -1745,9 +2512,11 @@ var init_node = __esm(() => {
   init_base();
   FILENAME_MATCH = /^\s*[-]{4,}$/;
   FULL_MATCH = /at (?:async )?(?:(.+?)\s+\()?(?:(.+):(\d+):(\d+)?|([^)]+))\)?/;
+  PROMISE_COMBINATOR = /^Promise\.(?:all|any)$/;
+  PROMISE_INDEX = /^index \d+$/;
 });
 
-// node_modules/.bun/@posthog+core@1.30.3/node_modules/@posthog/core/dist/error-tracking/parsers/index.mjs
+// node_modules/.bun/@posthog+core@1.48.9/node_modules/@posthog/core/dist/error-tracking/parsers/index.mjs
 function reverseAndStripFrames(stack) {
   if (!stack.length)
     return [];
@@ -1801,7 +2570,7 @@ var init_parsers = __esm(() => {
   WEBPACK_ERROR_REGEXP = /\(error: (.*)\)/;
 });
 
-// node_modules/.bun/@posthog+core@1.30.3/node_modules/@posthog/core/dist/error-tracking/coercers/dom-exception-coercer.mjs
+// node_modules/.bun/@posthog+core@1.48.9/node_modules/@posthog/core/dist/error-tracking/coercers/dom-exception-coercer.mjs
 class DOMExceptionCoercer {
   match(err) {
     return this.isDOMException(err) || this.isDOMError(err);
@@ -1835,18 +2604,20 @@ var init_dom_exception_coercer = __esm(() => {
   init_utils();
 });
 
-// node_modules/.bun/@posthog+core@1.30.3/node_modules/@posthog/core/dist/error-tracking/coercers/error-coercer.mjs
+// node_modules/.bun/@posthog+core@1.48.9/node_modules/@posthog/core/dist/error-tracking/coercers/error-coercer.mjs
 class ErrorCoercer {
   match(err) {
-    return isPlainError(err);
+    return isError(err);
   }
   coerce(err, ctx) {
+    const stack = this.getStack(err);
+    const synthetic = stack === undefined;
     return {
       type: this.getType(err),
       value: this.getMessage(err, ctx),
-      stack: this.getStack(err),
+      stack: stack ?? ctx.syntheticException?.stack,
       cause: err.cause ? ctx.next(err.cause) : undefined,
-      synthetic: false
+      synthetic
     };
   }
   getType(err) {
@@ -1863,32 +2634,48 @@ class ErrorCoercer {
   }
 }
 var init_error_coercer = __esm(() => {
-  init_utils();
+  init_type_utils();
 });
 
-// node_modules/.bun/@posthog+core@1.30.3/node_modules/@posthog/core/dist/error-tracking/coercers/error-event-coercer.mjs
+// node_modules/.bun/@posthog+core@1.48.9/node_modules/@posthog/core/dist/error-tracking/coercers/error-event-coercer.mjs
 class ErrorEventCoercer {
   constructor() {}
   match(err) {
-    return isErrorEvent(err) && err.error != null;
+    if (!isErrorEvent(err))
+      return false;
+    const errorEvent = err;
+    return errorEvent.error != null || this._hasUsableMessage(errorEvent);
   }
   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;
+    if (err.error != null)
+      return ctx.apply(err.error);
+    const exceptionLike = ctx.apply(err.message);
+    return {
+      ...exceptionLike,
+      stack: this._buildLocationStack(err) ?? exceptionLike.stack,
+      synthetic: true
+    };
+  }
+  _hasUsableMessage(err) {
+    return isString(err.message) && err.message.length > 0;
+  }
+  _buildLocationStack(err) {
+    const location = err;
+    const lineno = location.lineno ?? 0;
+    const colno = location.colno ?? 0;
+    if (!isString(location.filename) || location.filename.length === 0)
+      return;
+    if (lineno === 0)
+      return;
+    return `Error
+    at ${location.filename}:${lineno}:${colno}`;
   }
 }
 var init_error_event_coercer = __esm(() => {
   init_utils();
 });
 
-// node_modules/.bun/@posthog+core@1.30.3/node_modules/@posthog/core/dist/error-tracking/coercers/string-coercer.mjs
+// node_modules/.bun/@posthog+core@1.48.9/node_modules/@posthog/core/dist/error-tracking/coercers/string-coercer.mjs
 class StringCoercer {
   match(input) {
     return typeof input == "string";
@@ -1921,7 +2708,7 @@ var init_string_coercer = __esm(() => {
   ERROR_TYPES_PATTERN = /^(?:[Uu]ncaught (?:exception: )?)?(?:((?:Eval|Internal|Range|Reference|Syntax|Type|URI|)Error): )?(.*)$/i;
 });
 
-// node_modules/.bun/@posthog+core@1.30.3/node_modules/@posthog/core/dist/error-tracking/types.mjs
+// node_modules/.bun/@posthog+core@1.48.9/node_modules/@posthog/core/dist/error-tracking/types.mjs
 var severityLevels;
 var init_types2 = __esm(() => {
   severityLevels = [
@@ -1934,7 +2721,7 @@ var init_types2 = __esm(() => {
   ];
 });
 
-// node_modules/.bun/@posthog+core@1.30.3/node_modules/@posthog/core/dist/error-tracking/coercers/utils.mjs
+// node_modules/.bun/@posthog+core@1.48.9/node_modules/@posthog/core/dist/error-tracking/coercers/utils.mjs
 function extractExceptionKeysForMessage(err, maxLength = 40) {
   const keys = Object.keys(err);
   keys.sort();
@@ -1952,7 +2739,7 @@ function extractExceptionKeysForMessage(err, maxLength = 40) {
 }
 var init_utils2 = () => {};
 
-// node_modules/.bun/@posthog+core@1.30.3/node_modules/@posthog/core/dist/error-tracking/coercers/object-coercer.mjs
+// node_modules/.bun/@posthog+core@1.48.9/node_modules/@posthog/core/dist/error-tracking/coercers/object-coercer.mjs
 class ObjectCoercer {
   match(candidate) {
     return typeof candidate == "object" && candidate !== null;
@@ -1964,13 +2751,16 @@ class ObjectCoercer {
     return {
       type: this.getType(candidate),
       value: this.getValue(candidate),
-      stack: ctx.syntheticException?.stack,
+      stack: this.getStack(candidate) ?? ctx.syntheticException?.stack,
       level: this.isSeverityLevel(candidate.level) ? candidate.level : "error",
       synthetic: true
     };
   }
   getType(err) {
-    return isEvent(err) ? err.constructor.name : "Error";
+    if (isEvent(err))
+      return err.constructor.name;
+    const name = "name" in err ? err.name : undefined;
+    return isString(name) && !isEmptyString(name) ? name : "Error";
   }
   getValue(err) {
     if ("name" in err && typeof err.name == "string") {
@@ -1988,6 +2778,15 @@ class ObjectCoercer {
   isSeverityLevel(x) {
     return isString(x) && !isEmptyString(x) && severityLevels.indexOf(x) >= 0;
   }
+  getStack(candidate) {
+    try {
+      if (isString(candidate.stacktrace) && candidate.stacktrace.length > 0)
+        return candidate.stacktrace;
+      return isString(candidate.stack) && candidate.stack.length > 0 ? candidate.stack : undefined;
+    } catch {
+      return;
+    }
+  }
   getErrorPropertyFromObject(obj) {
     for (const prop in obj)
       if (Object.prototype.hasOwnProperty.call(obj, prop)) {
@@ -2011,7 +2810,7 @@ var init_object_coercer = __esm(() => {
   init_utils2();
 });
 
-// node_modules/.bun/@posthog+core@1.30.3/node_modules/@posthog/core/dist/error-tracking/coercers/event-coercer.mjs
+// node_modules/.bun/@posthog+core@1.48.9/node_modules/@posthog/core/dist/error-tracking/coercers/event-coercer.mjs
 class EventCoercer {
   match(err) {
     return isEvent(err);
@@ -2031,7 +2830,7 @@ var init_event_coercer = __esm(() => {
   init_utils2();
 });
 
-// node_modules/.bun/@posthog+core@1.30.3/node_modules/@posthog/core/dist/error-tracking/coercers/primitive-coercer.mjs
+// node_modules/.bun/@posthog+core@1.48.9/node_modules/@posthog/core/dist/error-tracking/coercers/primitive-coercer.mjs
 class PrimitiveCoercer {
   match(candidate) {
     return isPrimitive(candidate);
@@ -2049,7 +2848,7 @@ var init_primitive_coercer = __esm(() => {
   init_utils();
 });
 
-// node_modules/.bun/@posthog+core@1.30.3/node_modules/@posthog/core/dist/error-tracking/coercers/promise-rejection-event.mjs
+// node_modules/.bun/@posthog+core@1.48.9/node_modules/@posthog/core/dist/error-tracking/coercers/promise-rejection-event.mjs
 class PromiseRejectionEventCoercer {
   match(err) {
     return isBuiltin(err, "PromiseRejectionEvent") || this.isCustomEventWrappingRejection(err);
@@ -2089,7 +2888,7 @@ var init_promise_rejection_event = __esm(() => {
   init_utils();
 });
 
-// node_modules/.bun/@posthog+core@1.30.3/node_modules/@posthog/core/dist/error-tracking/coercers/index.mjs
+// node_modules/.bun/@posthog+core@1.48.9/node_modules/@posthog/core/dist/error-tracking/coercers/index.mjs
 var init_coercers = __esm(() => {
   init_dom_exception_coercer();
   init_error_coercer();
@@ -2101,7 +2900,7 @@ var init_coercers = __esm(() => {
   init_promise_rejection_event();
 });
 
-// node_modules/.bun/@posthog+core@1.30.3/node_modules/@posthog/core/dist/error-tracking/utils.mjs
+// node_modules/.bun/@posthog+core@1.48.9/node_modules/@posthog/core/dist/error-tracking/utils.mjs
 class ReduceableCache {
   constructor(_maxSize) {
     this._maxSize = _maxSize;
@@ -2128,7 +2927,7 @@ class ReduceableCache {
 }
 var init_utils3 = () => {};
 
-// node_modules/.bun/@posthog+core@1.30.3/node_modules/@posthog/core/dist/error-tracking/exception-steps.mjs
+// node_modules/.bun/@posthog+core@1.48.9/node_modules/@posthog/core/dist/error-tracking/exception-steps.mjs
 function resolveExceptionStepsConfig(config) {
   if (!config)
     return {
@@ -2211,9 +3010,12 @@ function normalizePositiveInteger(input, fallback) {
   return normalized;
 }
 function normalizeAndSerializeStep(step) {
-  const json = safeStringify(step);
-  if (!json)
+  let json;
+  try {
+    json = safeJsonStringify(step);
+  } catch {
     return;
+  }
   try {
     const parsed = JSON.parse(json);
     if (!isObject(parsed))
@@ -2233,33 +3035,6 @@ function normalizeAndSerializeStep(step) {
     return;
   }
 }
-function safeStringify(value) {
-  const seen = new WeakSet;
-  try {
-    return JSON.stringify(value, (_key, replacementValue) => {
-      if (typeof replacementValue == "bigint")
-        return replacementValue.toString();
-      if (typeof replacementValue == "function" || typeof replacementValue == "symbol")
-        return;
-      if (replacementValue instanceof Date)
-        return replacementValue.toISOString();
-      if (replacementValue instanceof Error)
-        return {
-          name: replacementValue.name,
-          message: replacementValue.message,
-          stack: replacementValue.stack
-        };
-      if (replacementValue && typeof replacementValue == "object") {
-        if (seen.has(replacementValue))
-          return "[Circular]";
-        seen.add(replacementValue);
-      }
-      return replacementValue;
-    });
-  } catch {
-    return;
-  }
-}
 function getUtf8ByteLength(value) {
   if (typeof TextEncoder != "undefined")
     return new TextEncoder().encode(value).length;
@@ -2290,34 +3065,42 @@ var init_exception_steps = __esm(() => {
   };
 });
 
-// node_modules/.bun/@posthog+core@1.30.3/node_modules/@posthog/core/dist/error-tracking/index.mjs
+// node_modules/.bun/@posthog+core@1.48.9/node_modules/@posthog/core/dist/error-tracking/release.mjs
+function getInjectedReleaseId() {
+  const injected = globalThis._posthogReleaseId;
+  return typeof injected == "string" && injected.length > 0 ? injected : undefined;
+}
+var init_release = () => {};
+
+// node_modules/.bun/@posthog+core@1.48.9/node_modules/@posthog/core/dist/error-tracking/index.mjs
 var exports_error_tracking = {};
 __export(exports_error_tracking, {
-  winjsStackLineParser: () => winjsStackLineParser,
-  stripReservedExceptionStepFields: () => stripReservedExceptionStepFields,
-  reverseAndStripFrames: () => reverseAndStripFrames,
-  resolveExceptionStepsConfig: () => resolveExceptionStepsConfig,
-  opera11StackLineParser: () => opera11StackLineParser,
-  opera10StackLineParser: () => opera10StackLineParser,
-  nodeStackLineParser: () => nodeStackLineParser,
-  getUtf8ByteLength: () => getUtf8ByteLength,
-  geckoStackLineParser: () => geckoStackLineParser,
-  createStackParser: () => createStackParser,
-  createDefaultStackParser: () => createDefaultStackParser,
-  chromeStackLineParser: () => chromeStackLineParser,
-  StringCoercer: () => StringCoercer,
-  ReduceableCache: () => ReduceableCache,
-  PromiseRejectionEventCoercer: () => PromiseRejectionEventCoercer,
-  PrimitiveCoercer: () => PrimitiveCoercer,
-  ObjectCoercer: () => ObjectCoercer,
-  ExceptionStepsBuffer: () => ExceptionStepsBuffer,
-  EventCoercer: () => EventCoercer,
-  ErrorPropertiesBuilder: () => ErrorPropertiesBuilder,
-  ErrorEventCoercer: () => ErrorEventCoercer,
-  ErrorCoercer: () => ErrorCoercer,
-  EXCEPTION_STEP_INTERNAL_FIELDS: () => EXCEPTION_STEP_INTERNAL_FIELDS,
+  DEFAULT_EXCEPTION_STEPS_CONFIG: () => DEFAULT_EXCEPTION_STEPS_CONFIG,
   DOMExceptionCoercer: () => DOMExceptionCoercer,
-  DEFAULT_EXCEPTION_STEPS_CONFIG: () => DEFAULT_EXCEPTION_STEPS_CONFIG
+  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,
+  getInjectedReleaseId: () => getInjectedReleaseId,
+  getUtf8ByteLength: () => getUtf8ByteLength,
+  nodeStackLineParser: () => nodeStackLineParser,
+  opera10StackLineParser: () => opera10StackLineParser,
+  opera11StackLineParser: () => opera11StackLineParser,
+  resolveExceptionStepsConfig: () => resolveExceptionStepsConfig,
+  reverseAndStripFrames: () => reverseAndStripFrames,
+  stripReservedExceptionStepFields: () => stripReservedExceptionStepFields,
+  winjsStackLineParser: () => winjsStackLineParser
 });
 var init_error_tracking = __esm(() => {
   init_error_properties_builder();
@@ -2325,15 +3108,19 @@ var init_error_tracking = __esm(() => {
   init_coercers();
   init_utils3();
   init_exception_steps();
+  init_release();
 });
 
-// node_modules/.bun/@posthog+core@1.30.3/node_modules/@posthog/core/dist/posthog-core-stateless.mjs
+// node_modules/.bun/@posthog+core@1.48.9/node_modules/@posthog/core/dist/posthog-core-stateless.mjs
 async function logFlushError(err) {
   if (err instanceof PostHogFetchHttpError) {
     let text = "";
     try {
       text = await err.text;
-    } catch {}
+    } catch {
+      if (err.bodyReadTimedOut)
+        text = "<response body read timed out>";
+    }
     console.error(`Error while flushing PostHog: message=${err.message}, response body=${text}`, err);
   } else
     console.error("Error while flushing PostHog", err);
@@ -2345,9 +3132,26 @@ function isPostHogFetchError(err) {
 function isPostHogFetchNetworkError(err) {
   return err instanceof PostHogFetchNetworkError;
 }
+function isRetryableFlagsFetchError(err) {
+  if (err instanceof PostHogFetchHttpError)
+    return err.status === 502 || err.status === 504;
+  if (!(err instanceof PostHogFetchNetworkError))
+    return false;
+  const cause = err.error;
+  const code = cause?.code ?? cause?.cause?.code;
+  return code !== "ECONNREFUSED";
+}
 function isPostHogFetchContentTooLargeError(err) {
   return typeof err == "object" && err instanceof PostHogFetchHttpError && err.status === 413;
 }
+function isPostHogFetchRetryableError(err) {
+  if (err instanceof PostHogFetchHttpError)
+    return err.status === 408 || err.status === 429 || err.status >= 500;
+  return isPostHogFetchNetworkError(err);
+}
+function isPostHogEventProperties(value) {
+  return value !== null && typeof value == "object" && !Array.isArray(value);
+}
 
 class PostHogCoreStateless {
   getErrorPropertiesBuilder() {
@@ -2365,6 +3169,9 @@ class PostHogCoreStateless {
   }
   constructor(apiKey, options = {}) {
     this.flushPromise = null;
+    this.pendingFlushPromise = null;
+    this.flushPromises = new Set;
+    this._dequeuedMessagesCount = 0;
     this.shutdownPromise = null;
     this.promiseQueue = new PromiseQueue;
     this._events = new SimpleEventEmitter;
@@ -2387,10 +3194,11 @@ class PostHogCoreStateless {
     this._retryOptions = {
       retryCount: options.fetchRetryCount ?? 3,
       retryDelay: options.fetchRetryDelay ?? 3000,
-      retryCheck: isPostHogFetchError
+      retryCheck: isPostHogFetchRetryableError
     };
     this.requestTimeout = options.requestTimeout ?? 1e4;
     this.featureFlagsRequestTimeoutMs = options.featureFlagsRequestTimeoutMs ?? 3000;
+    this.featureFlagsRequestMaxRetries = options.featureFlagsRequestMaxRetries ?? 1;
     this.remoteConfigRequestTimeoutMs = options.remoteConfigRequestTimeoutMs ?? 3000;
     this.disableGeoip = options.disableGeoip ?? true;
     this.disabled = (options.disabled ?? false) || missingApiKey;
@@ -2452,15 +3260,23 @@ class PostHogCoreStateless {
     return this.disabled;
   }
   buildPayload(payload) {
+    const userProperties = payload.properties || {};
+    let properties = {
+      ...userProperties,
+      ...this.getCommonEventProperties()
+    };
+    applyCallerFeatureFlagOverrides(properties, userProperties);
+    if (payload.event === "$feature_flag_called" && properties.$feature_flag_has_experiment === false && this.isMinimalFlagCalledEventsEnabled())
+      properties = minimizeFlagCalledEventProperties(properties);
     return {
       distinct_id: payload.distinct_id,
       event: payload.event,
-      properties: {
-        ...payload.properties || {},
-        ...this.getCommonEventProperties()
-      }
+      properties
     };
   }
+  isMinimalFlagCalledEventsEnabled() {
+    return false;
+  }
   addPendingPromise(promise) {
     return this.promiseQueue.add(promise);
   }
@@ -2545,6 +3361,19 @@ class PostHogCoreStateless {
       this.enqueue("capture", payload, options);
     });
   }
+  async groupIdentifyStatelessImmediate(groupType, groupKey, groupProperties, options, distinctId, eventProperties) {
+    const payload = this.buildPayload({
+      distinct_id: distinctId || `$${groupType}_${groupKey}`,
+      event: "$groupidentify",
+      properties: {
+        $group_type: groupType,
+        $group_key: groupKey,
+        $group_set: groupProperties || {},
+        ...eventProperties || {}
+      }
+    });
+    await this.sendImmediate("capture", payload, options);
+  }
   async getRemoteConfig() {
     await this._initPromise;
     let host = this.host;
@@ -2561,8 +3390,11 @@ class PostHogCoreStateless {
       }
     };
     return this.fetchWithRetry(url, fetchOptions, {
+      type: "required",
+      consume: (response) => response.json()
+    }, {
       retryCount: 0
-    }, this.remoteConfigRequestTimeoutMs).then((response) => response.json()).catch((error) => {
+    }, this.remoteConfigRequestTimeoutMs).catch((error) => {
       this._logger.error("Remote config could not be loaded", error);
       this._events.emit("error", error);
     });
@@ -2593,8 +3425,12 @@ class PostHogCoreStateless {
     };
     this._logger.info("Flags URL", url);
     return this.fetchWithRetry(url, fetchOptions, {
-      retryCount: 0
-    }, this.featureFlagsRequestTimeoutMs).then((response) => response.json()).then((response) => ({
+      type: "required",
+      consume: (response) => response.json()
+    }, {
+      retryCount: this.featureFlagsRequestMaxRetries,
+      retryCheck: isRetryableFlagsFetchError
+    }, this.featureFlagsRequestTimeoutMs).then((response) => ({
       success: true,
       response: normalizeFlagsResponse(response)
     })).catch((error) => {
@@ -2694,9 +3530,9 @@ class PostHogCoreStateless {
   }
   async getFeatureFlagDetailsStateless(distinctId, groups = {}, personProperties = {}, groupProperties = {}, disableGeoip, flagKeysToEvaluate) {
     await this._initPromise;
-    const extraPayload = {};
-    if (disableGeoip ?? this.disableGeoip)
-      extraPayload["geoip_disable"] = true;
+    const extraPayload = {
+      geoip_disable: disableGeoip ?? this.disableGeoip
+    };
     if (flagKeysToEvaluate)
       extraPayload["flag_keys_to_evaluate"] = flagKeysToEvaluate;
     const result = await this.getFlags(distinctId, groups, personProperties, groupProperties, extraPayload);
@@ -2733,15 +3569,18 @@ class PostHogCoreStateless {
         "Content-Type": "application/json"
       }
     };
-    const response = await this.fetchWithRetry(url, fetchOptions).then((response2) => {
-      if (response2.status !== 200 || !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;
+    const response = await this.fetchWithRetry(url, fetchOptions, {
+      type: "required",
+      consume: (response2) => {
+        if (response2.status !== 200 || !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 Promise.resolve(undefined);
+        }
+        return response2.json();
       }
-      return response2.json();
     }).catch((error) => {
       this._logger.error("Surveys API could not be loaded", error);
       this._events.emit("error", error);
@@ -2778,23 +3617,39 @@ class PostHogCoreStateless {
     return message;
   }
   async flushStorage() {}
-  enqueue(type, _message, options) {
+  getQueueRouteKey(_message) {
+    return DEFAULT_QUEUE_ROUTE;
+  }
+  persistedQueueKeyForRoute(_route) {
+    return types_PostHogPersistedProperty.Queue;
+  }
+  getActiveQueueRoutes() {
+    return [
+      DEFAULT_QUEUE_ROUTE
+    ];
+  }
+  getRouteQueue(route) {
+    return this.getPersistedProperty(this.persistedQueueKeyForRoute(route)) || [];
+  }
+  enqueue(type, _message, options, explicitRoute) {
     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);
+      let message = this.prepareMessage(_message, options);
       message = this.processBeforeEnqueue(message);
       if (message === null)
         return;
-      const queue = this.getPersistedProperty(types_PostHogPersistedProperty.Queue) || [];
+      message = this.normalizeMessage(message);
+      const queueKey = this.persistedQueueKeyForRoute(explicitRoute ?? this.getQueueRouteKey(message));
+      const queue = this.getPersistedProperty(queueKey) || [];
       if (queue.length >= this.maxQueueSize) {
         queue.shift();
-        this._logger.info("Queue is full, the oldest event is dropped.");
+        this._logger.warn("Queue is full, the oldest event is dropped.");
       }
       queue.push({
         message
       });
-      this.setPersistedProperty(types_PostHogPersistedProperty.Queue, queue);
+      this.setPersistedProperty(queueKey, queue);
       this._events.emit(type, message);
       if (queue.length >= this.flushAt)
         this.flushBackground();
@@ -2802,61 +3657,63 @@ class PostHogCoreStateless {
         this._flushTimer = safeSetTimeout(() => this.flushBackground(), this.flushInterval);
     });
   }
-  async sendImmediate(type, _message, options) {
+  async sendImmediate(type, _message, options, explicitRoute) {
     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);
+    let message = this.prepareMessage(_message, options);
     message = this.processBeforeEnqueue(message);
     if (message === null)
       return;
-    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",
-        ...gzippedPayload !== null && {
-          "Content-Encoding": "gzip"
-        }
-      },
-      body: gzippedPayload || payload
-    };
+    message = this.normalizeMessage(message);
     try {
-      const response = await this.fetchWithRetry(url, fetchOptions);
-      await response.body?.cancel()?.catch(() => {});
+      await this.sendBatch([
+        message
+      ], undefined, explicitRoute ?? this.getQueueRouteKey(message));
     } catch (err) {
       this._events.emit("error", err);
     }
   }
-  prepareMessage(type, _message, options) {
+  normalizeMessage(message) {
+    const { type: _type, library, library_version, ...sanitizedMessage } = message;
+    let properties = isPostHogEventProperties(sanitizedMessage.properties) ? sanitizedMessage.properties : undefined;
+    if (library !== undefined && properties?.$lib === undefined)
+      properties = {
+        ...properties || {},
+        $lib: library
+      };
+    if (library_version !== undefined && properties?.$lib_version === undefined)
+      properties = {
+        ...properties || {},
+        $lib_version: library_version
+      };
+    if (properties)
+      sanitizedMessage.properties = properties;
+    sanitizedMessage.uuid = getEventUuid(sanitizedMessage.uuid, uuidv7);
+    return sanitizedMessage;
+  }
+  normalizeTimestampForWire(timestamp) {
+    const parsedTimestamp = timestamp instanceof Date ? timestamp : typeof timestamp == "string" ? new Date(timestamp) : null;
+    if (!parsedTimestamp || Number.isNaN(parsedTimestamp.getTime()))
+      return timestamp;
+    const normalized = parsedTimestamp.toISOString();
+    const fractionalSeconds = typeof timestamp == "string" ? timestamp.match(/\.(\d+)(?:Z|[+-]\d{2}:?\d{2})?$/i)?.[1] : undefined;
+    return fractionalSeconds && fractionalSeconds.length > 3 ? normalized.replace(/\.\d{3}Z$/, `.${fractionalSeconds}Z`) : normalized;
+  }
+  prepareMessage(_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()
+      uuid: getEventUuid(options?.uuid, uuidv7)
     };
     const addGeoipDisableProperty = options?.disableGeoip ?? this.disableGeoip;
     if (addGeoipDisableProperty) {
-      if (!message.properties)
+      if (!isPostHogEventProperties(message.properties))
         message.properties = {};
-      message["properties"]["$geoip_disable"] = true;
+      message.properties["$geoip_disable"] = true;
     }
     if (message.distinctId) {
       message.distinct_id = message.distinctId;
@@ -2871,21 +3728,64 @@ class PostHogCoreStateless {
     }
   }
   flushBackground() {
+    if (this.pendingFlushPromise)
+      return;
     this.flush().catch(async (err) => {
       await logFlushError(err);
     });
   }
-  async flush() {
+  async waitForPendingPromises(maxPromiseId, ignoredPromises = []) {
+    const ignoredPendingPromises = ignoredPromises.filter((promise) => !!promise);
+    let iteration = 0;
+    while (true) {
+      const promises = this.promiseQueue.getPromises([
+        ...ignoredPendingPromises,
+        ...this.flushPromises
+      ], maxPromiseId);
+      if (promises.length === 0)
+        return;
+      if (iteration > 0)
+        this._logger.debug(`flush() re-checking ${promises.length} pending promise(s) before flushing`);
+      await Promise.all(promises.map((promise) => promise.catch(() => {})));
+      iteration++;
+    }
+  }
+  flushWithPendingPromises() {
+    return this.flushInternal(true);
+  }
+  flush() {
+    return this.flushInternal(false);
+  }
+  flushInternal(waitForPendingPromises) {
     if (this.disabled)
-      return;
-    const nextFlushPromise = allSettled([
-      this.flushPromise
-    ]).then(() => this._flush());
+      return Promise.resolve();
+    if (!waitForPendingPromises && this.pendingFlushPromise)
+      return this.pendingFlushPromise;
+    const previousFlushPromise = this.flushPromise;
+    const maxPromiseId = this.promiseQueue.maxId;
+    const nextFlushPromise = Promise.resolve().then(() => {
+      if (waitForPendingPromises)
+        return this.waitForPendingPromises(maxPromiseId, [
+          previousFlushPromise,
+          nextFlushPromise
+        ]);
+    }).then(() => allSettled([
+      previousFlushPromise
+    ])).then(() => {
+      if (this.pendingFlushPromise === nextFlushPromise)
+        this.pendingFlushPromise = null;
+      return this._flush();
+    });
+    this.pendingFlushPromise = nextFlushPromise;
     this.flushPromise = nextFlushPromise;
+    this.flushPromises.add(nextFlushPromise);
     this.addPendingPromise(nextFlushPromise);
     allSettled([
       nextFlushPromise
     ]).then(() => {
+      this.flushPromises.delete(nextFlushPromise);
+      if (this.pendingFlushPromise === nextFlushPromise)
+        this.pendingFlushPromise = null;
       if (this.flushPromise === nextFlushPromise)
         this.flushPromise = null;
     });
@@ -2898,55 +3798,102 @@ class PostHogCoreStateless {
       headers["User-Agent"] = customUserAgent;
     return headers;
   }
+  compressPayload(payload) {
+    return gzipCompress(payload, this.isDebug);
+  }
+  getBatchEndpointPath(_route) {
+    return "/batch/";
+  }
+  async sendBatch(batchMessages, retryOptions, route = DEFAULT_QUEUE_ROUTE) {
+    const data = {
+      api_key: this.apiKey,
+      batch: batchMessages.map((message) => {
+        if (!message)
+          return message;
+        const timestamp = this.normalizeTimestampForWire(message.timestamp);
+        return timestamp === message.timestamp ? message : {
+          ...message,
+          timestamp
+        };
+      }),
+      sent_at: currentISOTime()
+    };
+    if (this.historicalMigration)
+      data.historical_migration = true;
+    const payload = safeJsonStringify(data);
+    const url = `${this.host}${this.getBatchEndpointPath(route)}`;
+    const gzippedPayload = this.disableCompression ? null : await this.compressPayload(payload);
+    const fetchOptions = {
+      method: "POST",
+      headers: {
+        ...this.getCustomHeaders(),
+        "Content-Type": "application/json",
+        ...gzippedPayload !== null && {
+          "Content-Encoding": "gzip"
+        }
+      },
+      body: gzippedPayload || payload
+    };
+    await this.fetchWithRetry(url, fetchOptions, {
+      type: "successful-write"
+    }, retryOptions);
+  }
   async _flush() {
     this.clearFlushTimer();
     await this._initPromise;
-    let queue = this.getPersistedProperty(types_PostHogPersistedProperty.Queue) || [];
-    if (!queue.length)
+    const routes = this.getActiveQueueRoutes();
+    if (!routes.some((route) => this.getRouteQueue(route).length > 0))
       return;
     const sentMessages = [];
+    let firstError;
+    for (const route of routes)
+      try {
+        await this._flushRoute(route, sentMessages);
+      } catch (err) {
+        if (firstError === undefined)
+          firstError = err;
+      }
+    if (firstError !== undefined)
+      throw firstError;
+    this._events.emit("flush", sentMessages);
+  }
+  async _flushRoute(route, sentMessages) {
+    const queueKey = this.persistedQueueKeyForRoute(route);
+    let queue = this.getPersistedProperty(queueKey) || [];
+    if (!queue.length)
+      return;
     const originalQueueLength = queue.length;
-    while (queue.length > 0 && sentMessages.length < originalQueueLength) {
+    let sentFromRoute = 0;
+    while (queue.length > 0 && sentFromRoute < originalQueueLength) {
       const batchItems = queue.slice(0, this.maxBatchSize);
-      const batchMessages = batchItems.map((item) => item.message);
+      const batchMessages = batchItems.map((item) => item.message === undefined ? 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);
+        const refreshedQueue = this.getPersistedProperty(queueKey) || [];
+        const remainingBatchItems = [
+          ...batchItems
+        ];
+        const newQueue = refreshedQueue.filter((item) => {
+          const itemUuid = item.message?.uuid;
+          const batchItemIndex = remainingBatchItems.findIndex((batchItem) => batchItem === item || typeof itemUuid == "string" && itemUuid.length > 0 && batchItem.message?.uuid === itemUuid);
+          if (batchItemIndex === -1)
+            return true;
+          remainingBatchItems.splice(batchItemIndex, 1);
+          return false;
+        });
+        this.setPersistedProperty(queueKey, newQueue);
         queue = newQueue;
+        this._dequeuedMessagesCount += batchItems.length;
         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",
-          ...gzippedPayload !== null && {
-            "Content-Encoding": "gzip"
-          }
-        },
-        body: gzippedPayload || payload
-      };
       const retryOptions = {
         retryCheck: (err) => {
           if (isPostHogFetchContentTooLargeError(err))
             return false;
-          return isPostHogFetchError(err);
+          return isPostHogFetchRetryableError(err);
         }
       };
       try {
-        const response = await this.fetchWithRetry(url, fetchOptions, retryOptions);
-        await response.body?.cancel()?.catch(() => {});
+        await this.sendBatch(batchMessages, retryOptions, route);
       } catch (err) {
         if (isPostHogFetchContentTooLargeError(err) && batchMessages.length > 1) {
           this.maxBatchSize = Math.max(1, Math.floor(batchMessages.length / 2));
@@ -2960,18 +3907,67 @@ class PostHogCoreStateless {
       }
       await persistQueueChange();
       sentMessages.push(...batchMessages);
+      sentFromRoute += batchMessages.length;
+    }
+  }
+  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 this.compressPayload(serialized);
+    const fetchOptions = {
+      method: "POST",
+      headers: {
+        ...this.getCustomHeaders(),
+        "Content-Type": "application/json",
+        ...gzippedPayload !== null && {
+          "Content-Encoding": "gzip"
+        }
+      },
+      body: gzippedPayload || serialized
+    };
+    try {
+      await this.fetchWithRetry(url, fetchOptions, {
+        type: "successful-write"
+      }, {
+        retryCheck: (err) => {
+          if (isPostHogFetchContentTooLargeError(err))
+            return false;
+          return isPostHogFetchRetryableError(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
+      };
     }
-    this._events.emit("flush", sentMessages);
   }
-  async _sendLogsBatch(payload) {
+  async _sendMetricsBatch(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 url = `${this.host}/i/v1/metrics?token=${encodeURIComponent(this.apiKey)}`;
+    const gzippedPayload = this.disableCompression ? null : await this.compressPayload(serialized);
     const fetchOptions = {
       method: "POST",
       headers: {
@@ -2985,10 +3981,12 @@ class PostHogCoreStateless {
     };
     try {
       await this.fetchWithRetry(url, fetchOptions, {
+        type: "successful-write"
+      }, {
         retryCheck: (err) => {
           if (isPostHogFetchContentTooLargeError(err))
             return false;
-          return isPostHogFetchError(err);
+          return isPostHogFetchRetryableError(err);
         }
       });
       return {
@@ -2999,7 +3997,7 @@ class PostHogCoreStateless {
         return {
           kind: "too-large"
         };
-      if (err instanceof PostHogFetchNetworkError)
+      if (isPostHogFetchRetryableError(err))
         return {
           kind: "retry-later",
           error: err
@@ -3010,41 +4008,106 @@ class PostHogCoreStateless {
       };
     }
   }
-  async fetchWithRetry(url, options, retryOptions, requestTimeout) {
+  async fetchWithRetry(url, options, responseHandling, retryOptions, requestTimeout) {
     const body = options.body ? options.body : "";
     let reqByteLength = -1;
     try {
-      reqByteLength = body instanceof Blob ? body.size : Buffer.byteLength(body, STRING_FORMAT);
+      reqByteLength = body instanceof Blob ? body.size : body instanceof Uint8Array ? body.byteLength : Buffer.byteLength(body, STRING_FORMAT);
     } catch {
       if (body instanceof Blob)
         reqByteLength = body.size;
+      else if (body instanceof Uint8Array)
+        reqByteLength = body.byteLength;
       else {
         const encoded = new TextEncoder().encode(body);
         reqByteLength = encoded.length;
       }
     }
+    const retriableOptions = {
+      ...this._retryOptions,
+      ...retryOptions
+    };
+    let attempt = 0;
     return await retriable(async () => {
+      attempt++;
       const ctrl = new AbortController;
       const timeoutMs = requestTimeout ?? this.requestTimeout;
-      const timer = safeSetTimeout(() => ctrl.abort(), timeoutMs);
-      let res = null;
+      const requestDeadline = Date.now() + timeoutMs;
+      let timer;
+      const deadline = new Promise((_resolve, reject) => {
+        timer = safeSetTimeout(() => {
+          const timeoutError = new Error(`Request timed out after ${timeoutMs}ms`);
+          timeoutError.name = "AbortError";
+          reject(timeoutError);
+          ctrl.abort(timeoutError);
+        }, timeoutMs);
+      });
+      let res;
+      let responseAccepted = false;
+      let cancellation;
+      const cancelBody = () => cancellation ??= (async () => {
+        try {
+          await res?.body?.cancel();
+        } catch {}
+      })();
       try {
-        res = await this.fetch(url, {
-          signal: ctrl.signal,
-          ...options
-        });
-      } catch (e) {
-        throw new PostHogFetchNetworkError(e);
+        let fetchPromise;
+        try {
+          fetchPromise = this.fetch(url, {
+            signal: ctrl.signal,
+            ...options
+          });
+        } catch (e) {
+          throw new PostHogFetchNetworkError(e);
+        }
+        fetchPromise.then((lateResponse) => {
+          if (ctrl.signal.aborted && !responseAccepted)
+            Promise.resolve(lateResponse.body?.cancel()).catch(() => {});
+        }).catch(() => {});
+        try {
+          res = await Promise.race([
+            fetchPromise,
+            deadline
+          ]);
+          responseAccepted = true;
+        } catch (e) {
+          throw new PostHogFetchNetworkError(e);
+        }
+        const isNoCors = options.mode === "no-cors";
+        if (!isNoCors && (res.status < 200 || res.status >= 400))
+          throw new PostHogFetchHttpError(res, reqByteLength, requestDeadline, ctrl);
+        if (responseHandling.type === "successful-write") {
+          try {
+            await Promise.race([
+              cancelBody(),
+              deadline
+            ]);
+          } catch {}
+          return;
+        }
+        try {
+          return await Promise.race([
+            responseHandling.consume(res),
+            deadline
+          ]);
+        } catch (e) {
+          if (ctrl.signal.aborted)
+            throw new PostHogFetchNetworkError(e);
+          throw e;
+        }
       } finally {
         clearTimeout(timer);
+        if (ctrl.signal.aborted && res)
+          cancelBody();
       }
-      const isNoCors = options.mode === "no-cors";
-      if (!isNoCors && (res.status < 200 || res.status >= 400))
-        throw new PostHogFetchHttpError(res, reqByteLength);
-      return res;
     }, {
-      ...this._retryOptions,
-      ...retryOptions
+      ...retriableOptions,
+      retryCheck: (error) => {
+        const shouldRetry = retriableOptions.retryCheck(error);
+        if (shouldRetry && attempt <= retriableOptions.retryCount && error instanceof PostHogFetchHttpError)
+          error.cancelResponseBody();
+        return shouldRetry;
+      }
     });
   }
   async _shutdown(shutdownTimeoutMs = 30000) {
@@ -3057,12 +4120,17 @@ class PostHogCoreStateless {
       try {
         await this.promiseQueue.join();
         while (true) {
-          const queue = this.getPersistedProperty(types_PostHogPersistedProperty.Queue) || [];
-          if (queue.length === 0)
+          const hasQueuedEvents = this.getActiveQueueRoutes().some((route) => this.getRouteQueue(route).length > 0);
+          if (!hasQueuedEvents)
             break;
+          const dequeuedBeforeFlush = this._dequeuedMessagesCount;
           await this.flush();
           if (hasTimedOut)
             break;
+          if (this._dequeuedMessagesCount === dequeuedBeforeFlush) {
+            this._logger.warn("Shutdown flush completed but did not send any queued events. Stopping drain to avoid a loop.");
+            break;
+          }
         }
       } catch (e) {
         if (!isPostHogFetchError(e))
@@ -3070,21 +4138,12 @@ class PostHogCoreStateless {
         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);
-    }
+    return raceWithTimeout(doShutdown(), shutdownTimeoutMs, () => {
+      this._logger.critical("Timeout while shutting down PostHog. Some events may not have been sent.", {
+        shutdownTimeoutMs
+      });
+      hasTimedOut = true;
+    });
   }
   async shutdown(shutdownTimeoutMs = 30000) {
     if (this.shutdownPromise)
@@ -3096,7 +4155,11 @@ class PostHogCoreStateless {
     return this.shutdownPromise;
   }
 }
-var PostHogFetchHttpError, PostHogFetchNetworkError;
+var PostHogFetchHttpError, PostHogFetchNetworkError, applyCallerFeatureFlagOverrides = (target, callerProperties) => {
+  for (const key of Object.keys(callerProperties))
+    if (key.startsWith("$feature/") || key === "$active_feature_flags")
+      target[key] = callerProperties[key];
+}, DEFAULT_QUEUE_ROUTE = "default";
 var init_posthog_core_stateless = __esm(() => {
   init_eventemitter();
   init_featureFlagUtils();
@@ -3106,17 +4169,58 @@ var init_posthog_core_stateless = __esm(() => {
   init_uuidv7();
   init_error_tracking();
   PostHogFetchHttpError = class PostHogFetchHttpError extends Error {
-    constructor(response, reqByteLength) {
-      super("HTTP error while fetching PostHog: status=" + response.status + ", reqByteLength=" + reqByteLength), this.response = response, this.reqByteLength = reqByteLength, this.name = "PostHogFetchHttpError";
+    constructor(response, reqByteLength, responseBodyDeadline, abortController) {
+      super("HTTP error while fetching PostHog: status=" + response.status + ", reqByteLength=" + reqByteLength), this.response = response, this.reqByteLength = reqByteLength, this.responseBodyDeadline = responseBodyDeadline, this.abortController = abortController, this.name = "PostHogFetchHttpError", this._bodyReadTimedOut = false;
     }
     get status() {
       return this.response.status;
     }
+    get bodyReadTimedOut() {
+      return this._bodyReadTimedOut;
+    }
     get text() {
-      return this.response.text();
+      if (!this.responseBodyTextPromise)
+        if (Date.now() >= this.responseBodyDeadline) {
+          this._bodyReadTimedOut = true;
+          const timeoutError = new Error("Response body read timed out");
+          timeoutError.name = "AbortError";
+          this.cancelResponseBody(timeoutError);
+          this.responseBodyTextPromise = Promise.reject(timeoutError);
+        } else {
+          const responseBodyTimeout = new Promise((_resolve, reject) => {
+            this.responseBodyTimer = safeSetTimeout(() => {
+              this._bodyReadTimedOut = true;
+              const timeoutError = new Error("Response body read timed out");
+              timeoutError.name = "AbortError";
+              reject(timeoutError);
+              this.cancelResponseBody(timeoutError);
+            }, this.responseBodyDeadline - Date.now());
+          });
+          let responseBodyText;
+          try {
+            responseBodyText = Promise.resolve(this.response.text());
+          } catch (error) {
+            responseBodyText = Promise.reject(error);
+          }
+          this.responseBodyTextPromise = Promise.race([
+            responseBodyText,
+            responseBodyTimeout
+          ]).finally(() => clearTimeout(this.responseBodyTimer));
+        }
+      return this.responseBodyTextPromise;
     }
     get json() {
-      return this.response.json();
+      return this.text.then((text) => JSON.parse(text));
+    }
+    cancelResponseBody(reason) {
+      clearTimeout(this.responseBodyTimer);
+      if (!this.abortController.signal.aborted)
+        this.abortController.abort(reason);
+      (async () => {
+        try {
+          await this.response.body?.cancel();
+        } catch {}
+      })();
     }
   };
   PostHogFetchNetworkError = class PostHogFetchNetworkError extends Error {
@@ -3128,7 +4232,7 @@ var init_posthog_core_stateless = __esm(() => {
   };
 });
 
-// node_modules/.bun/@posthog+core@1.30.3/node_modules/@posthog/core/dist/posthog-core.mjs
+// node_modules/.bun/@posthog+core@1.48.9/node_modules/@posthog/core/dist/posthog-core.mjs
 var init_posthog_core = __esm(() => {
   init_featureFlagUtils();
   init_types();
@@ -3137,17 +4241,18 @@ var init_posthog_core = __esm(() => {
   init_utils();
 });
 
-// node_modules/.bun/@posthog+core@1.30.3/node_modules/@posthog/core/dist/tracing-headers.mjs
+// node_modules/.bun/@posthog+core@1.48.9/node_modules/@posthog/core/dist/tracing-headers.mjs
 var init_tracing_headers = __esm(() => {
   init_type_utils();
 });
 
-// node_modules/.bun/@posthog+core@1.30.3/node_modules/@posthog/core/dist/index.mjs
+// node_modules/.bun/@posthog+core@1.48.9/node_modules/@posthog/core/dist/index.mjs
 var init_dist = __esm(() => {
   init_featureFlagUtils();
   init_gzip();
   init_logs_utils();
   init_logs();
+  init_metrics();
   init_uuidv7();
   init_validation();
   init_error_tracking();
@@ -3159,16 +4264,24 @@ var init_dist = __esm(() => {
   init_types();
 });
 
-// node_modules/.bun/posthog-node@5.35.12/node_modules/posthog-node/dist/extensions/error-tracking/modifiers/context-lines.node.mjs
-import { createReadStream } from "node:fs";
+// node_modules/.bun/posthog-node@5.51.1/node_modules/posthog-node/dist/extensions/error-tracking/modifiers/context-lines.node.mjs
+import { constants as constants3 } from "node:fs";
+import { open as promises_open } from "node:fs/promises";
+import { isAbsolute as isAbsolute7 } from "node:path";
 import { createInterface } from "node:readline";
-async function addSourceContext(frames) {
+async function addSourceContext(frames, openSourceFile = promises_open, logger2) {
   const filesToLines = {};
+  let basePath;
+  try {
+    basePath = process.cwd();
+  } catch {}
   for (let i = frames.length - 1;i >= 0; i--) {
     const frame = frames[i];
     const filename = frame?.filename;
     if (!frame || typeof filename != "string" || typeof frame.lineno != "number" || shouldSkipContextLinesForFile(filename) || shouldSkipContextLinesForFrame(frame))
       continue;
+    if (!isAbsolute7(filename) && basePath === undefined)
+      continue;
     const filesToLinesOutput = filesToLines[filename];
     if (!filesToLinesOutput)
       filesToLines[filename] = [];
@@ -3179,50 +4292,98 @@ async function addSourceContext(frames) {
     return frames;
   const readlinePromises = [];
   for (const file of files) {
-    if (LRU_FILE_CONTENTS_FS_READ_FAILED.get(file))
+    const cacheKey = makeSourceCacheKey(file, basePath);
+    if (cacheKey === undefined)
+      continue;
+    if (LRU_FILE_CONTENTS_FS_READ_FAILED.get(cacheKey))
       continue;
     const filesToLineRanges = filesToLines[file];
     if (!filesToLineRanges)
       continue;
     filesToLineRanges.sort((a, b) => a - b);
     const ranges = makeLineReaderRanges(filesToLineRanges);
-    if (ranges.every((r) => rangeExistsInContentCache(file, r)))
+    if (ranges.every((r) => rangeExistsInContentCache(cacheKey, r)))
       continue;
-    const cache = emplace(LRU_FILE_CONTENTS_CACHE, file, {});
-    readlinePromises.push(getContextLinesFromFile(file, ranges, cache));
+    const cache = emplace(LRU_FILE_CONTENTS_CACHE, cacheKey, {});
+    readlinePromises.push(getContextLinesFromFile(file, ranges, cache, cacheKey, openSourceFile, logger2));
   }
   await Promise.all(readlinePromises).catch(() => {});
   if (frames && frames.length > 0)
-    addSourceContextToFrames(frames, LRU_FILE_CONTENTS_CACHE);
+    addSourceContextToFrames(frames, LRU_FILE_CONTENTS_CACHE, basePath);
   LRU_FILE_CONTENTS_CACHE.reduce();
   return frames;
 }
-function getContextLinesFromFile(path2, ranges, output) {
+async function openRegularSourceFile(path2, openSourceFile, logger2) {
+  let fileHandle;
+  let isValid = false;
+  try {
+    fileHandle = await openSourceFile(path2, constants3.O_RDONLY | constants3.O_NONBLOCK);
+    const fileStat = await fileHandle.stat();
+    if (!fileStat.isFile())
+      return;
+    if (fileStat.size > MAX_CONTEXTLINES_FILE_SIZE)
+      return void logger2?.debug(`Skipping source context for oversized file ${path2}: ${fileStat.size} bytes exceeds ${MAX_CONTEXTLINES_FILE_SIZE}`);
+    isValid = true;
+    return fileHandle;
+  } catch {
+    return;
+  } finally {
+    if (fileHandle && !isValid)
+      await fileHandle.close().catch(() => {});
+  }
+}
+async function getContextLinesFromFile(path2, ranges, output, cacheKey, openSourceFile, logger2) {
+  const fileHandle = await openRegularSourceFile(path2, openSourceFile, logger2);
+  if (fileHandle === undefined)
+    return void LRU_FILE_CONTENTS_FS_READ_FAILED.set(cacheKey, 1);
+  const openedFileHandle = fileHandle;
   return new Promise((resolve9) => {
-    const stream = createReadStream(path2);
-    const lineReaded = createInterface({
-      input: stream
-    });
-    function destroyStreamAndResolve() {
-      stream.destroy();
-      resolve9();
+    let finished = false;
+    function destroyStreamAndResolve(stream2) {
+      if (finished)
+        return;
+      finished = true;
+      stream2?.destroy();
+      openedFileHandle.close().then(resolve9, resolve9);
+    }
+    let stream;
+    try {
+      stream = openedFileHandle.createReadStream({
+        autoClose: false,
+        start: 0,
+        end: MAX_CONTEXTLINES_FILE_SIZE - 1
+      });
+    } catch {
+      LRU_FILE_CONTENTS_FS_READ_FAILED.set(cacheKey, 1);
+      destroyStreamAndResolve();
+      return;
+    }
+    let lineReaded;
+    try {
+      lineReaded = createInterface({
+        input: stream
+      });
+    } catch {
+      LRU_FILE_CONTENTS_FS_READ_FAILED.set(cacheKey, 1);
+      destroyStreamAndResolve(stream);
+      return;
     }
     let lineNumber = 0;
     let currentRangeIndex = 0;
     const range = ranges[currentRangeIndex];
     if (range === undefined)
-      return void destroyStreamAndResolve();
+      return void destroyStreamAndResolve(stream);
     let rangeStart = range[0];
     let rangeEnd = range[1];
     function onStreamError() {
-      LRU_FILE_CONTENTS_FS_READ_FAILED.set(path2, 1);
+      LRU_FILE_CONTENTS_FS_READ_FAILED.set(cacheKey, 1);
       lineReaded.close();
       lineReaded.removeAllListeners();
-      destroyStreamAndResolve();
+      destroyStreamAndResolve(stream);
     }
     stream.on("error", onStreamError);
     lineReaded.on("error", onStreamError);
-    lineReaded.on("close", destroyStreamAndResolve);
+    lineReaded.on("close", () => destroyStreamAndResolve(stream));
     lineReaded.on("line", (line) => {
       lineNumber++;
       if (lineNumber < rangeStart)
@@ -3247,10 +4408,11 @@ function getContextLinesFromFile(path2, ranges, output) {
     });
   });
 }
-function addSourceContextToFrames(frames, cache) {
+function addSourceContextToFrames(frames, cache, basePath) {
   for (const frame of frames)
     if (frame.filename && frame.context_line === undefined && typeof frame.lineno == "number") {
-      const contents = cache.get(frame.filename);
+      const cacheKey = makeSourceCacheKey(frame.filename, basePath);
+      const contents = cacheKey === undefined ? undefined : cache.get(cacheKey);
       if (contents === undefined)
         continue;
       addContextToFrame(frame.lineno, frame, contents);
@@ -3293,8 +4455,19 @@ function shouldSkipContextLinesForFrame(frame) {
     return true;
   return false;
 }
-function rangeExistsInContentCache(file, range) {
-  const contents = LRU_FILE_CONTENTS_CACHE.get(file);
+function makeSourceCacheKey(path2, basePath) {
+  if (isAbsolute7(path2))
+    return JSON.stringify([
+      null,
+      path2
+    ]);
+  return basePath === undefined ? undefined : JSON.stringify([
+    basePath,
+    path2
+  ]);
+}
+function rangeExistsInContentCache(cacheKey, range) {
+  const contents = LRU_FILE_CONTENTS_CACHE.get(cacheKey);
   if (contents === undefined)
     return false;
   for (let i = range[0];i <= range[1]; i++)
@@ -3371,15 +4544,15 @@ function snipLine(line, colno) {
     newLine += "...";
   return newLine;
 }
-var LRU_FILE_CONTENTS_CACHE, LRU_FILE_CONTENTS_FS_READ_FAILED, DEFAULT_LINES_OF_CONTEXT = 7, MAX_CONTEXTLINES_COLNO = 1000, MAX_CONTEXTLINES_LINENO = 1e4;
+var LRU_FILE_CONTENTS_CACHE, LRU_FILE_CONTENTS_FS_READ_FAILED, DEFAULT_LINES_OF_CONTEXT = 7, MAX_CONTEXTLINES_COLNO = 1000, MAX_CONTEXTLINES_LINENO = 1e4, MAX_CONTEXTLINES_FILE_SIZE = 10485760;
 var init_context_lines_node = __esm(() => {
   init_dist();
   LRU_FILE_CONTENTS_CACHE = new exports_error_tracking.ReduceableCache(25);
   LRU_FILE_CONTENTS_FS_READ_FAILED = new exports_error_tracking.ReduceableCache(20);
 });
 
-// node_modules/.bun/posthog-node@5.35.12/node_modules/posthog-node/dist/extensions/error-tracking/modifiers/relative-path.node.mjs
-import { isAbsolute as isAbsolute7, relative as relative4, sep as sep8 } from "node:path";
+// node_modules/.bun/posthog-node@5.51.1/node_modules/posthog-node/dist/extensions/error-tracking/modifiers/relative-path.node.mjs
+import { isAbsolute as isAbsolute8, relative as relative4, sep as sep8 } from "node:path";
 function createRelativePathModifier(basePath = process.cwd()) {
   const isWindows = sep8 === "\\";
   const toUnix = (p) => isWindows ? p.replace(/\\/g, "/") : p;
@@ -3387,7 +4560,7 @@ function createRelativePathModifier(basePath = process.cwd()) {
   return async (frames) => {
     for (const frame of frames)
       if (!(!frame.filename || frame.filename.startsWith("node:") || frame.filename.startsWith("data:"))) {
-        if (isAbsolute7(frame.filename))
+        if (isAbsolute8(frame.filename))
           frame.filename = toUnix(relative4(normalizedBase, toUnix(frame.filename)));
       }
     return frames;
@@ -3395,11 +4568,11 @@ function createRelativePathModifier(basePath = process.cwd()) {
 }
 var init_relative_path_node = () => {};
 
-// node_modules/.bun/posthog-node@5.35.12/node_modules/posthog-node/dist/version.mjs
-var version = "5.35.12";
+// node_modules/.bun/posthog-node@5.51.1/node_modules/posthog-node/dist/version.mjs
+var version = "5.51.1";
 var init_version = () => {};
 
-// node_modules/.bun/posthog-node@5.35.12/node_modules/posthog-node/dist/types.mjs
+// node_modules/.bun/posthog-node@5.51.1/node_modules/posthog-node/dist/types.mjs
 var FeatureFlagError2;
 var init_types3 = __esm(() => {
   FeatureFlagError2 = {
@@ -3410,7 +4583,7 @@ var init_types3 = __esm(() => {
   };
 });
 
-// node_modules/.bun/posthog-node@5.35.12/node_modules/posthog-node/dist/feature-flag-evaluations.mjs
+// node_modules/.bun/posthog-node@5.51.1/node_modules/posthog-node/dist/feature-flag-evaluations.mjs
 class FeatureFlagEvaluations {
   constructor(init) {
     this._host = init.host;
@@ -3426,10 +4599,10 @@ class FeatureFlagEvaluations {
     this._accessed = init.accessed ?? new Set;
     this._isSlice = init.isSlice ?? false;
   }
-  isEnabled(key) {
+  isEnabled(key, options = {}) {
     const flag = this._flags[key];
     this._recordAccess(key);
-    return flag?.enabled ?? false;
+    return flag?.enabled ?? options.defaultValue ?? false;
   }
   getFlag(key) {
     const flag = this._flags[key];
@@ -3519,6 +4692,8 @@ class FeatureFlagEvaluations {
       $feature_flag_request_id: this._requestId,
       $feature_flag_evaluated_at: flag?.locallyEvaluated ? Date.now() : this._evaluatedAt
     };
+    if (flag?.hasExperiment !== undefined)
+      properties.$feature_flag_has_experiment = flag.hasExperiment;
     if (flag?.locallyEvaluated && this._flagDefinitionsLoadedAt !== undefined)
       properties.$feature_flag_definitions_loaded_at = this._flagDefinitionsLoadedAt;
     const errors = [];
@@ -3544,7 +4719,7 @@ var init_feature_flag_evaluations = __esm(() => {
   init_types3();
 });
 
-// node_modules/.bun/posthog-node@5.35.12/node_modules/posthog-node/dist/extensions/feature-flags/crypto.mjs
+// node_modules/.bun/posthog-node@5.51.1/node_modules/posthog-node/dist/extensions/feature-flags/crypto.mjs
 async function hashSHA1(text) {
   const subtle = globalThis.crypto?.subtle;
   if (!subtle)
@@ -3555,12 +4730,19 @@ async function hashSHA1(text) {
 }
 var init_crypto = () => {};
 
-// node_modules/.bun/posthog-node@5.35.12/node_modules/posthog-node/dist/extensions/feature-flags/feature-flags.mjs
+// node_modules/.bun/posthog-node@5.51.1/node_modules/posthog-node/dist/extensions/feature-flags/feature-flags.mjs
+function setCustomErrorPrototype(error, constructor) {
+  error.name = constructor.name;
+  Error.captureStackTrace(error, constructor);
+  Object.setPrototypeOf(error, constructor.prototype);
+}
+
 class FeatureFlagsPoller {
   constructor({ pollingInterval, personalApiKey, projectApiKey, timeout, host, customHeaders, ...options }) {
     this.debugMode = false;
     this.shouldBeginExponentialBackoff = false;
     this.backOffCount = 0;
+    this.pollerStopped = false;
     this.pollingInterval = pollingInterval;
     this.personalApiKey = personalApiKey;
     this.featureFlags = [];
@@ -3576,6 +4758,7 @@ class FeatureFlagsPoller {
     this.onError = options.onError;
     this.customHeaders = customHeaders;
     this.onLoad = options.onLoad;
+    this.onMinimalFlagCalledEvents = options.onMinimalFlagCalledEvents;
     this.cacheProvider = options.cacheProvider;
     this.strictLocalEvaluation = options.strictLocalEvaluation ?? false;
     this.loadFeatureFlags();
@@ -3773,6 +4956,7 @@ class FeatureFlagsPoller {
     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;
@@ -3796,12 +4980,15 @@ class FeatureFlagsPoller {
             effectiveBucketingValue = groups[groupName];
           }
         }
-        if (await this.isConditionMatch(flag, effectiveBucketingValue, condition, effectiveProperties, evaluationContext)) {
+        const matchResult = await this.isConditionMatch(flag, effectiveBucketingValue, condition, effectiveProperties, evaluationContext);
+        if (matchResult === "match") {
           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 && matchResult === "out_of_rollout_bound")
+          return false;
       } catch (e) {
         if (e instanceof RequiresServerEvaluation)
           throw e;
@@ -3825,16 +5012,20 @@ class FeatureFlagsPoller {
       for (const prop of condition.properties) {
         const propertyType = prop.type;
         let matches = false;
-        matches = propertyType === "cohort" ? await matchCohort(prop, properties, this.cohorts, this.debugMode, (depProp) => this.evaluateFlagDependency(depProp, properties, evaluationContext)) : propertyType === "flag" ? await this.evaluateFlagDependency(prop, properties, evaluationContext) : matchProperty(prop, properties, warnFunction);
+        if (propertyType === "cohort") {
+          const inCohort = await matchCohort(prop, properties, this.cohorts, this.debugMode, (depProp) => this.evaluateFlagDependency(depProp, properties, evaluationContext));
+          matches = prop.operator === "not_in" ? !inCohort : inCohort;
+        } else
+          matches = propertyType === "flag" ? await this.evaluateFlagDependency(prop, properties, evaluationContext) : matchProperty(prop, properties, warnFunction);
         if (!matches)
-          return false;
+          return "no_match";
       }
       if (rolloutPercentage == undefined)
-        return true;
+        return "match";
     }
     if (rolloutPercentage != null && await _hash(flag.key, bucketingValue) > rolloutPercentage / 100)
-      return false;
-    return true;
+      return "out_of_rollout_bound";
+    return "match";
   }
   async getMatchingVariant(flag, bucketingValue) {
     const hashValue = await _hash(flag.key, bucketingValue, "variant");
@@ -3865,6 +5056,7 @@ class FeatureFlagsPoller {
     this.groupTypeMapping = flagData.groupTypeMapping;
     this.cohorts = flagData.cohorts;
     this.loadedSuccessfullyOnce = true;
+    this.onMinimalFlagCalledEvents?.(flagData.minimalFlagCalledEvents === true);
   }
   warnAboutExperienceContinuityFlags(flags) {
     if (this.strictLocalEvaluation)
@@ -3928,7 +5120,6 @@ class FeatureFlagsPoller {
       clearTimeout(this.poller);
       this.poller = undefined;
     }
-    this.poller = setTimeout(() => this.loadFeatureFlags(true), this.getPollingInterval());
     try {
       let shouldFetch = true;
       if (this.cacheProvider)
@@ -3956,17 +5147,18 @@ class FeatureFlagsPoller {
           return;
         case 401:
           this.beginBackoff();
-          throw new ClientError(`Your project key or personal API key is invalid. Setting next polling interval to ${this.getPollingInterval()}ms. More information: https://posthog.com/docs/api#rate-limiting`);
+          throw new ClientError(`Your project key or secret key is invalid. Setting next polling interval to ${this.getPollingInterval()}ms. More information: https://posthog.com/docs/api#rate-limiting`);
         case 402:
           console.warn("[FEATURE FLAGS] Feature flags quota limit exceeded - unsetting all local flags. Learn more about billing limits at https://posthog.com/docs/billing/limits-alerts");
           this.featureFlags = [];
           this.featureFlagsByKey = {};
           this.groupTypeMapping = {};
           this.cohorts = {};
+          this.onMinimalFlagCalledEvents?.(false);
           return;
         case 403:
           this.beginBackoff();
-          throw new ClientError(`Your personal API key does not have permission to fetch feature flag definitions for local evaluation. Setting next polling interval to ${this.getPollingInterval()}ms. Are you sure you're using the correct personal and Project API key pair? More information: https://posthog.com/docs/api/overview`);
+          throw new ClientError(`Your secret key does not have permission to fetch feature flag definitions for local evaluation. Setting next polling interval to ${this.getPollingInterval()}ms. Are you sure you're using the correct secret and Project API key pair? More information: https://posthog.com/docs/api/overview`);
         case 429:
           this.beginBackoff();
           throw new ClientError(`You are being rate limited. Setting next polling interval to ${this.getPollingInterval()}ms. More information: https://posthog.com/docs/api#rate-limiting`);
@@ -3978,7 +5170,8 @@ class FeatureFlagsPoller {
           const flagData = {
             flags: responseJson.flags ?? [],
             groupTypeMapping: responseJson.group_type_mapping || {},
-            cohorts: responseJson.cohorts || {}
+            cohorts: responseJson.cohorts || {},
+            minimalFlagCalledEvents: responseJson.minimal_flag_called_events === true
           };
           this.updateFlagState(flagData);
           this.flagDefinitionsLoadedAt = Date.now();
@@ -3999,6 +5192,9 @@ class FeatureFlagsPoller {
     } catch (err) {
       if (err instanceof ClientError)
         this.onError?.(err);
+    } finally {
+      if (!this.pollerStopped)
+        this.poller = setTimeout(() => this.loadFeatureFlags(true), this.getPollingInterval());
     }
   }
   getPersonalApiKeyRequestOptions(method = "GET", etag) {
@@ -4014,7 +5210,7 @@ class FeatureFlagsPoller {
       headers
     };
   }
-  _requestFeatureFlagDefinitions() {
+  async _requestFeatureFlagDefinitions() {
     const url = `${this.host}/flags/definitions?token=${this.projectApiKey}&send_cohorts`;
     const options = this.getPersonalApiKeyRequestOptions("GET", this.flagsEtag);
     let abortTimeout = null;
@@ -4025,23 +5221,49 @@ class FeatureFlagsPoller {
       }, this.timeout);
       options.signal = controller.signal;
     }
+    const clearAbortTimeout = () => clearTimeout(abortTimeout);
     try {
       const fetch1 = this.fetch;
-      return fetch1(url, options);
-    } finally {
-      clearTimeout(abortTimeout);
+      const res = await fetch1(url, options);
+      if (res.status !== 200) {
+        clearAbortTimeout();
+        return res;
+      }
+      return {
+        status: res.status,
+        headers: res.headers,
+        body: res.body,
+        text: async () => {
+          try {
+            return await res.text();
+          } finally {
+            clearAbortTimeout();
+          }
+        },
+        json: async () => {
+          try {
+            return await res.json();
+          } finally {
+            clearAbortTimeout();
+          }
+        }
+      };
+    } catch (err) {
+      clearAbortTimeout();
+      throw err;
     }
   }
   async stopPoller(timeoutMs = 30000) {
+    this.pollerStopped = true;
     clearTimeout(this.poller);
+    this.poller = undefined;
     if (this.cacheProvider)
       try {
         const shutdownResult = this.cacheProvider.shutdown();
         if (shutdownResult instanceof Promise)
-          await Promise.race([
-            shutdownResult,
-            new Promise((_, reject) => setTimeout(() => reject(new Error(`Cache shutdown timeout after ${timeoutMs}ms`)), timeoutMs))
-          ]);
+          await raceWithTimeout(shutdownResult, timeoutMs, () => {
+            throw new Error(`Cache shutdown timeout after ${timeoutMs}ms`);
+          });
       } catch (err) {
         this.onError?.(new Error(`Error during cache shutdown: ${err}`));
       }
@@ -4096,6 +5318,14 @@ function matchProperty(property, propertyValues, warnFunction) {
       return String(overrideValue).toLowerCase().includes(String(value).toLowerCase());
     case "not_icontains":
       return !String(overrideValue).toLowerCase().includes(String(value).toLowerCase());
+    case "starts_with":
+      return String(overrideValue).toLowerCase().startsWith(String(value).toLowerCase());
+    case "not_starts_with":
+      return !String(overrideValue).toLowerCase().startsWith(String(value).toLowerCase());
+    case "ends_with":
+      return String(overrideValue).toLowerCase().endsWith(String(value).toLowerCase());
+    case "not_ends_with":
+      return !String(overrideValue).toLowerCase().endsWith(String(value).toLowerCase());
     case "regex":
       return isValidRegex(String(value)) && String(overrideValue).match(String(value)) !== null;
     case "not_regex":
@@ -4441,34 +5671,70 @@ var init_feature_flags = __esm(() => {
   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);
     }
   };
   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);
     }
   };
 });
 
-// node_modules/.bun/posthog-node@5.35.12/node_modules/posthog-node/dist/extensions/error-tracking/autocapture.mjs
+// node_modules/.bun/posthog-node@5.51.1/node_modules/posthog-node/dist/extensions/error-tracking/autocapture.mjs
+function splitNodeOptions(nodeOptions) {
+  const args = [];
+  let current = "";
+  let isInString = false;
+  for (let index = 0;index < nodeOptions.length; index++) {
+    const character = nodeOptions[index];
+    if (character === "\\" && isInString && index + 1 < nodeOptions.length)
+      current += nodeOptions[++index];
+    else if (character !== " " || isInString)
+      if (character === '"')
+        isInString = !isInString;
+      else
+        current += character;
+    else if (current) {
+      args.push(current);
+      current = "";
+    }
+  }
+  if (current)
+    args.push(current);
+  return args;
+}
+function findUnhandledRejectionMode(args) {
+  let mode;
+  for (let index = 0;index < args.length; index++) {
+    const argument = args[index];
+    const optionName = UNHANDLED_REJECTION_OPTION_NAMES.find((name) => argument === name || argument.startsWith(`${name}=`));
+    if (!optionName)
+      continue;
+    const value = argument === optionName ? args[++index] : argument.slice(optionName.length + 1);
+    if (UNHANDLED_REJECTION_MODES.has(value))
+      mode = value;
+  }
+  return mode;
+}
+function getUnhandledRejectionMode(execArgv = STARTUP_EXEC_ARGV, nodeOptions = STARTUP_NODE_OPTIONS) {
+  return findUnhandledRejectionMode(execArgv) ?? findUnhandledRejectionMode(splitNodeOptions(nodeOptions ?? "")) ?? "throw";
+}
+function captureUncaughtException(captureFn, error, origin) {
+  captureFn(error, {
+    mechanism: {
+      type: origin === "unhandledRejection" ? "onunhandledrejection" : "onuncaughtexception",
+      handled: false
+    }
+  });
+}
 function makeUncaughtExceptionHandler(captureFn, onFatalFn) {
   let calledFatalError = false;
-  return Object.assign((error) => {
+  return Object.assign((error, origin) => {
     const userProvidedListenersCount = global.process.listeners("uncaughtException").filter((listener) => listener.name !== "domainUncaughtExceptionClear" && listener._posthogErrorHandler !== true).length;
-    const processWouldExit = userProvidedListenersCount === 0;
-    captureFn(error, {
-      mechanism: {
-        type: "onuncaughtexception",
-        handled: false
-      }
-    });
-    if (!calledFatalError && processWouldExit) {
+    captureUncaughtException(captureFn, error, origin);
+    if (!calledFatalError && userProvidedListenersCount === 0) {
       calledFatalError = true;
       onFatalFn(error);
     }
@@ -4476,28 +5742,55 @@ function makeUncaughtExceptionHandler(captureFn, onFatalFn) {
     _posthogErrorHandler: true
   });
 }
-function addUncaughtExceptionListener(captureFn, onFatalFn) {
-  globalThis.process?.on("uncaughtException", makeUncaughtExceptionHandler(captureFn, onFatalFn));
+function addUncaughtExceptionListener(captureFn, onFatalFn, mode = STARTUP_UNHANDLED_REJECTION_MODE) {
+  const process2 = globalThis.process;
+  if (!process2)
+    return;
+  if (mode === "strict")
+    return void process2.on("uncaughtExceptionMonitor", (error, origin) => captureUncaughtException(captureFn, error, origin));
+  process2.on("uncaughtException", makeUncaughtExceptionHandler(captureFn, onFatalFn));
 }
-function addUnhandledRejectionListener(captureFn) {
-  globalThis.process?.on("unhandledRejection", (reason) => captureFn(reason, {
-    mechanism: {
-      type: "onunhandledrejection",
-      handled: false
-    }
-  }));
+function addUnhandledRejectionListener(captureFn, mode = STARTUP_UNHANDLED_REJECTION_MODE) {
+  const process2 = globalThis.process;
+  if (!process2 || mode === "throw" || mode === "strict" || mode === "warn-with-error-code")
+    return;
+  process2.on("unhandledRejection", (reason) => {
+    captureFn(reason, {
+      mechanism: {
+        type: "onunhandledrejection",
+        handled: false
+      }
+    });
+  });
 }
-var init_autocapture = () => {};
+var UNHANDLED_REJECTION_OPTION_NAMES, UNHANDLED_REJECTION_MODES, STARTUP_EXEC_ARGV, STARTUP_NODE_OPTIONS, STARTUP_UNHANDLED_REJECTION_MODE;
+var init_autocapture = __esm(() => {
+  UNHANDLED_REJECTION_OPTION_NAMES = [
+    "--unhandled-rejections",
+    "--unhandled_rejections"
+  ];
+  UNHANDLED_REJECTION_MODES = new Set([
+    "throw",
+    "strict",
+    "warn",
+    "warn-with-error-code",
+    "none"
+  ]);
+  STARTUP_EXEC_ARGV = [
+    ...globalThis.process?.execArgv ?? []
+  ];
+  STARTUP_NODE_OPTIONS = globalThis.process?.env?.NODE_OPTIONS;
+  STARTUP_UNHANDLED_REJECTION_MODE = getUnhandledRejectionMode();
+});
 
-// node_modules/.bun/posthog-node@5.35.12/node_modules/posthog-node/dist/extensions/error-tracking/index.mjs
-class ErrorTracking {
+// node_modules/.bun/posthog-node@5.51.1/node_modules/posthog-node/dist/extensions/error-tracking/index.mjs
+class error_tracking_ErrorTracking {
   constructor(client, options, _logger) {
     this.client = client;
     this._exceptionAutocaptureEnabled = options.enableExceptionAutocapture || false;
     this._logger = _logger;
     this._rateLimiter = new BucketedRateLimiter({
-      refillRate: 1,
-      bucketSize: 10,
+      ...resolveExceptionRateLimiterConfig(options),
       refillInterval: 1e4,
       _logger: this._logger
     });
@@ -4506,76 +5799,536 @@ class ErrorTracking {
   static isPreviouslyCapturedError(x) {
     return isObject(x) && "__posthog_previously_captured_error" in x && x.__posthog_previously_captured_error === true;
   }
-  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
+  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);
+    const injectedReleaseId = exports_error_tracking.getInjectedReleaseId();
+    if (injectedReleaseId)
+      properties.$release_id = injectedReleaseId;
+    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 (!error_tracking_ErrorTracking.isPreviouslyCapturedError(exception)) {
+        const eventMessage = await error_tracking_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._capturePreparedEvent(eventMessage, false);
+      }
+    })());
+  }
+  async onFatalError(exception) {
+    console.error(exception);
+    await this.client.shutdown(SHUTDOWN_TIMEOUT);
+    globalThis.process.exit(1);
+  }
+  isEnabled() {
+    return !this.client.isDisabled && this._exceptionAutocaptureEnabled;
+  }
+  shutdown() {
+    this._rateLimiter.stop();
+  }
+}
+var SHUTDOWN_TIMEOUT = 2000;
+var init_error_tracking2 = __esm(() => {
+  init_autocapture();
+  init_dist();
+});
+
+// node_modules/.bun/posthog-node@5.51.1/node_modules/posthog-node/dist/storage-memory.mjs
+class PostHogMemoryStorage {
+  getProperty(key) {
+    return this._memoryStorage[key];
+  }
+  setProperty(key, value) {
+    this._memoryStorage[key] = value !== null ? value : undefined;
+  }
+  constructor() {
+    this._memoryStorage = {};
+  }
+}
+var init_storage_memory = () => {};
+
+// node_modules/.bun/posthog-node@5.51.1/node_modules/posthog-node/dist/capture-v1/config.mjs
+function isCaptureMode(value) {
+  return value === "v0" || value === "v1";
+}
+function resolveCaptureMode() {
+  const envMode = typeof process != "undefined" ? process.env?.POSTHOG_CAPTURE_MODE : undefined;
+  return isCaptureMode(envMode) ? envMode : "v0";
+}
+var init_config2 = () => {};
+
+// node_modules/.bun/posthog-node@5.51.1/node_modules/posthog-node/dist/capture-v1/routing.mjs
+function isLegacyOnlyEvent(message) {
+  return typeof message.event == "string" && message.event.startsWith(AI_EVENT_PREFIX);
+}
+var AI_EVENT_PREFIX = "$ai_", ANALYTICS_ROUTE = "analytics", AI_ROUTE = "ai";
+var init_routing = () => {};
+
+// node_modules/.bun/posthog-node@5.51.1/node_modules/posthog-node/dist/capture-v1/errors.mjs
+var CaptureV1Error;
+var init_errors = __esm(() => {
+  CaptureV1Error = class CaptureV1Error extends Error {
+    constructor({ requestId, drops, retryExhausted, cause }) {
+      super(CaptureV1Error.buildMessage(requestId, drops, retryExhausted, cause)), this.name = "CaptureV1Error";
+      this.requestId = requestId;
+      this.drops = drops;
+      this.retryExhausted = retryExhausted;
+      this.cause = cause;
+    }
+    static buildMessage(requestId, drops, retryExhausted, cause) {
+      let message = `Capture V1 batch ${requestId} did not fully deliver: ${drops.length} dropped, ${retryExhausted.length} undelivered`;
+      if (cause instanceof Error)
+        message += ` (${cause.message})`;
+      return message;
+    }
+  };
+});
+
+// node_modules/.bun/posthog-node@5.51.1/node_modules/posthog-node/dist/capture-v1/transform.mjs
+function coerceBool(value) {
+  if (typeof value == "boolean")
+    return value;
+  if (typeof value == "number")
+    return value !== 0;
+  if (typeof value == "string") {
+    const normalized = value.trim().toLowerCase();
+    if (normalized === "true" || normalized === "1")
+      return true;
+    if (normalized === "false" || normalized === "0")
+      return false;
+  }
+}
+function coerceString(value) {
+  return typeof value == "string" ? value : undefined;
+}
+function isRecord3(value) {
+  return typeof value == "object" && value !== null && !Array.isArray(value);
+}
+function toRfc3339(timestamp) {
+  if (typeof timestamp == "string") {
+    const asDate2 = new Date(timestamp);
+    if (Number.isNaN(asDate2.getTime()))
+      return new Date().toISOString();
+    const normalized = asDate2.toISOString();
+    const fractionalSeconds = timestamp.match(/\.(\d+)(?:Z|[+-]\d{2}:?\d{2})?$/i)?.[1];
+    return fractionalSeconds && fractionalSeconds.length > 3 ? normalized.replace(/\.\d{3}Z$/, `.${fractionalSeconds}Z`) : normalized;
+  }
+  if (timestamp instanceof Date)
+    return Number.isNaN(timestamp.getTime()) ? new Date().toISOString() : timestamp.toISOString();
+  const asDate = timestamp == null ? new Date : new Date(timestamp);
+  return Number.isNaN(asDate.getTime()) ? new Date().toISOString() : asDate.toISOString();
+}
+function relocateInto(properties, key, value) {
+  if (value !== undefined && !(key in properties))
+    properties[key] = value;
+}
+function buildV1Event(message) {
+  const sourceProperties = isRecord3(message.properties) ? message.properties : {};
+  const properties = {
+    ...sourceProperties
+  };
+  const options = {};
+  for (const { property, optionKey, coerce } of OPTION_SENTINELS)
+    if (property in properties) {
+      const coerced = coerce(properties[property]);
+      if (coerced !== undefined)
+        options[optionKey] = coerced;
+      delete properties[property];
+    }
+  const topLevel = {};
+  for (const { property, field } of TOPLEVEL_SENTINELS)
+    if (property in properties) {
+      const value = properties[property];
+      if (typeof value == "string")
+        topLevel[field] = value;
+      delete properties[property];
+    }
+  delete properties.$lib;
+  delete properties.$lib_version;
+  relocateInto(properties, "$set", message.$set);
+  relocateInto(properties, "$set_once", message.$set_once);
+  return {
+    event: String(message.event ?? ""),
+    uuid: String(message.uuid ?? ""),
+    distinct_id: String(message.distinct_id ?? ""),
+    timestamp: toRfc3339(message.timestamp),
+    ...topLevel,
+    options,
+    properties
+  };
+}
+function buildV1Batch(messages, { createdAt, historicalMigration }) {
+  const batch = {
+    created_at: createdAt,
+    batch: messages.map(buildV1Event)
+  };
+  if (historicalMigration)
+    batch.historical_migration = true;
+  return batch;
+}
+var OPTION_SENTINELS, TOPLEVEL_SENTINELS;
+var init_transform = __esm(() => {
+  OPTION_SENTINELS = [
+    {
+      property: "$cookieless_mode",
+      optionKey: "cookieless_mode",
+      coerce: coerceBool
+    },
+    {
+      property: "$ignore_sent_at",
+      optionKey: "disable_skew_correction",
+      coerce: coerceBool
+    },
+    {
+      property: "$process_person_profile",
+      optionKey: "process_person_profile",
+      coerce: coerceBool
+    },
+    {
+      property: "$product_tour_id",
+      optionKey: "product_tour_id",
+      coerce: coerceString
+    }
+  ];
+  TOPLEVEL_SENTINELS = [
+    {
+      property: "$session_id",
+      field: "session_id"
+    },
+    {
+      property: "$window_id",
+      field: "window_id"
+    }
+  ];
+});
+
+// node_modules/.bun/posthog-node@5.51.1/node_modules/posthog-node/dist/capture-v1/sender.mjs
+class V1CaptureSender {
+  constructor(config, hooks) {
+    this.config = config;
+    this.maxBackoffMs = config.maxBackoffMs ?? DEFAULT_MAX_BACKOFF_MS;
+    this.fetchFn = hooks.fetch;
+    this.onError = hooks.onError;
+    this.now = hooks.now ?? Date.now;
+    this.sleep = hooks.sleep ?? ((ms) => new Promise((resolve9) => safeSetTimeout(resolve9, ms)));
+    this.generateRequestId = hooks.generateRequestId ?? uuidv7;
+    this.compress = hooks.compress ?? gzipCompress;
+  }
+  async sendV1Batch(messages) {
+    if (messages.length === 0)
+      return;
+    const requestId = this.generateRequestId();
+    const createdAt = new Date(this.now()).toISOString();
+    const { batch } = buildV1Batch(messages, {
+      createdAt,
+      historicalMigration: this.config.historicalMigration
+    });
+    const url = `${this.config.host}${V1_ANALYTICS_PATH}`;
+    const drops = [];
+    let pending = batch;
+    const maxAttempts = Math.max(1, this.config.maxAttempts);
+    for (let attempt = 1;attempt <= maxAttempts; attempt++) {
+      const isLastAttempt = attempt === maxAttempts;
+      const payload = safeJsonStringify({
+        created_at: createdAt,
+        ...this.config.historicalMigration ? {
+          historical_migration: true
+        } : {},
+        batch: pending
+      });
+      let captureAttempt;
+      let retryDelayMs;
+      try {
+        captureAttempt = await this.sendOnce(url, payload, attempt, requestId);
+        const { response, signal } = captureAttempt;
+        const { status } = response;
+        if (status < 200 || status >= 300)
+          if (!isLastAttempt && RETRYABLE_STATUSES.has(status)) {
+            const retryAfterMs = this.parseRetryAfter(response);
+            await captureAttempt.waitFor(captureAttempt.cancelBody()).catch(() => {});
+            retryDelayMs = this.backoffDelay(attempt, retryAfterMs);
+          } else {
+            const httpError = await this.buildHttpError(response, status, captureAttempt.waitFor);
+            return this.surfaceBatchFailure(requestId, drops, pending, httpError);
+          }
+        else {
+          let parsed;
+          try {
+            parsed = await captureAttempt.waitFor(this.parseResponse(response));
+          } catch (error) {
+            if (signal.aborted)
+              throw error;
+            return this.surfaceBatchFailure(requestId, drops, pending, new Error(`Capture V1 returned an unparseable ${status} response body`));
+          }
+          const retryable = this.classify(pending, parsed, drops);
+          if (retryable.length === 0)
+            return this.surfacePartialDrops(requestId, drops);
+          if (isLastAttempt)
+            return void this.onError(new CaptureV1Error({
+              requestId,
+              drops,
+              retryExhausted: retryable.map((event) => event.uuid)
+            }));
+          pending = retryable;
+          const retryAfterMs = this.parseRetryAfter(response);
+          retryDelayMs = this.backoffDelay(attempt, retryAfterMs);
+        }
+      } catch (transportError) {
+        if (captureAttempt && !captureAttempt.signal.aborted)
+          throw transportError;
+        if (isLastAttempt)
+          return this.surfaceBatchFailure(requestId, drops, pending, transportError);
+        retryDelayMs = this.backoffDelay(attempt);
+      } finally {
+        captureAttempt?.cleanup();
+      }
+      if (retryDelayMs !== undefined)
+        await this.sleep(retryDelayMs);
+    }
+  }
+  async sendOnce(url, payload, attempt, requestId) {
+    const headers = this.buildHeaders(attempt, requestId);
+    let body = payload;
+    if (this.config.compressionEnabled) {
+      const compressed = await this.compress(payload, this.config.isDebug);
+      if (compressed !== null) {
+        body = compressed;
+        headers["Content-Encoding"] = "gzip";
+      }
+    }
+    const controller = new AbortController;
+    let timeoutPhase = "waiting for response headers";
+    let timer;
+    const deadline = new Promise((_resolve, reject) => {
+      timer = safeSetTimeout(() => {
+        const timeoutError = new Error(`Capture V1 request timed out ${timeoutPhase} after ${this.config.requestTimeoutMs}ms`);
+        timeoutError.name = "AbortError";
+        reject(timeoutError);
+        controller.abort(timeoutError);
+      }, this.config.requestTimeoutMs);
+    });
+    try {
+      const fetchPromise = this.fetchFn(url, {
+        method: "POST",
+        headers,
+        body,
+        signal: controller.signal
+      });
+      let responseAccepted = false;
+      fetchPromise.then((lateResponse) => {
+        if (controller.signal.aborted && !responseAccepted)
+          this.cancelBody(lateResponse);
+      }).catch(() => {});
+      const response = await Promise.race([
+        fetchPromise,
+        deadline
+      ]);
+      responseAccepted = true;
+      timeoutPhase = "while reading the response body";
+      let cleanedUp = false;
+      let cancellation;
+      const cancelBody = () => cancellation ??= this.cancelBody(response);
+      return {
+        response,
+        signal: controller.signal,
+        waitFor: (operation) => Promise.race([
+          operation,
+          deadline
+        ]),
+        cancelBody,
+        cleanup: () => {
+          if (cleanedUp)
+            return;
+          cleanedUp = true;
+          clearTimeout(timer);
+          if (controller.signal.aborted)
+            cancelBody();
+        }
+      };
+    } catch (error) {
+      clearTimeout(timer);
+      throw error;
+    }
+  }
+  buildHeaders(attempt, requestId) {
+    const sdkInfo = `${this.config.libraryId}/${this.config.libraryVersion}`;
+    const headers = {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${this.config.apiKey}`,
+      "PostHog-Sdk-Info": sdkInfo,
+      "PostHog-Attempt": String(attempt),
+      "PostHog-Request-Id": requestId,
+      "PostHog-Request-Timestamp": new Date(this.now()).toISOString()
     };
+    if (this.config.userAgent)
+      headers["User-Agent"] = this.config.userAgent;
+    return headers;
   }
-  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
+  classify(pending, parsed, drops) {
+    const results = parsed.results ?? {};
+    const retryable = [];
+    for (const event of pending) {
+      const result = results[event.uuid];
+      if (result) {
+        if (result.result === "drop")
+          drops.push({
+            uuid: event.uuid,
+            details: result.details ?? undefined
           });
-        return this.client.capture(eventMessage);
+        else if (result.result === "retry")
+          retryable.push(event);
       }
-    })());
+    }
+    return retryable;
   }
-  async onFatalError(exception) {
-    console.error(exception);
-    await this.client.shutdown(SHUTDOWN_TIMEOUT);
-    process.exit(1);
+  backoffDelay(attempt, retryAfterMs) {
+    const exponential = Math.min(this.config.initialRetryDelayMs * 2 ** (attempt - 1), this.maxBackoffMs);
+    if (retryAfterMs === undefined)
+      return exponential;
+    return Math.max(exponential, Math.min(retryAfterMs, this.maxBackoffMs));
   }
-  isEnabled() {
-    return !this.client.isDisabled && this._exceptionAutocaptureEnabled;
+  parseRetryAfter(response) {
+    const raw = response.headers?.get("Retry-After");
+    if (!raw)
+      return;
+    const trimmed = raw.trim();
+    if (/^\d+$/.test(trimmed)) {
+      const seconds = parseInt(trimmed, 10);
+      return Number.isFinite(seconds) && seconds > 0 ? 1000 * seconds : undefined;
+    }
+    const dateMs = Date.parse(trimmed);
+    if (Number.isNaN(dateMs))
+      return;
+    const delta = dateMs - this.now();
+    return delta > 0 ? delta : undefined;
+  }
+  async parseResponse(response) {
+    const text = await response.text();
+    const parsed = JSON.parse(text);
+    if (typeof parsed != "object" || parsed === null || Array.isArray(parsed))
+      throw new Error("unexpected response shape");
+    const results = parsed.results;
+    if (results !== undefined && (typeof results != "object" || results === null || Array.isArray(results)))
+      throw new Error("unexpected results shape");
+    return {
+      results: results ?? {}
+    };
   }
-  shutdown() {
-    this._rateLimiter.stop();
+  async buildHttpError(response, status, waitFor) {
+    let bodyText = "";
+    try {
+      bodyText = (await waitFor(response.text())).slice(0, 512);
+    } catch {}
+    const suffix = bodyText ? `: ${bodyText}` : "";
+    return new Error(`Capture V1 request failed with HTTP ${status}${suffix}`);
+  }
+  surfaceBatchFailure(requestId, drops, pending, cause) {
+    this.onError(new CaptureV1Error({
+      requestId,
+      drops,
+      retryExhausted: pending.map((event) => event.uuid),
+      cause
+    }));
+  }
+  surfacePartialDrops(requestId, drops) {
+    if (drops.length > 0)
+      this.onError(new CaptureV1Error({
+        requestId,
+        drops,
+        retryExhausted: []
+      }));
+  }
+  async cancelBody(response) {
+    try {
+      await response.body?.cancel();
+    } catch {}
   }
 }
-var SHUTDOWN_TIMEOUT = 2000;
-var init_error_tracking2 = __esm(() => {
-  init_autocapture();
+var V1_ANALYTICS_PATH = "/i/v1/analytics/events", DEFAULT_MAX_BACKOFF_MS = 30000, RETRYABLE_STATUSES;
+var init_sender = __esm(() => {
   init_dist();
+  init_errors();
+  init_transform();
+  RETRYABLE_STATUSES = new Set([
+    408,
+    500,
+    502,
+    503,
+    504
+  ]);
 });
 
-// node_modules/.bun/posthog-node@5.35.12/node_modules/posthog-node/dist/storage-memory.mjs
-class PostHogMemoryStorage {
-  getProperty(key) {
-    return this._memoryStorage[key];
-  }
-  setProperty(key, value) {
-    this._memoryStorage[key] = value !== null ? value : undefined;
-  }
-  constructor() {
-    this._memoryStorage = {};
+// node_modules/.bun/posthog-node@5.51.1/node_modules/posthog-node/dist/ai-capture/routing.mjs
+var AI_CAPTURE_ROUTE = "ai-capture", AI_CAPTURE_ENDPOINT_PATH = "/i/v0/ai/batch/", AI_MAX_EVENT_BYTES = 8388608, AI_BATCH_TARGET_BYTES = 5242880;
+var init_routing2 = () => {};
+
+// node_modules/.bun/posthog-node@5.51.1/node_modules/posthog-node/dist/ai-capture/batching.mjs
+function eventByteSize(message) {
+  return encoder.encode(safeJsonStringify(message)).length;
+}
+function partitionAiBatch(messages, maxEventBytes = AI_MAX_EVENT_BYTES, targetBatchBytes = AI_BATCH_TARGET_BYTES) {
+  const batches = [];
+  const dropped = [];
+  let current = [];
+  let currentBytes = 0;
+  for (const message of messages) {
+    if (message === undefined)
+      continue;
+    const bytes = eventByteSize(message);
+    if (bytes > maxEventBytes) {
+      dropped.push({
+        event: typeof message.event == "string" ? message.event : "unknown",
+        bytes
+      });
+      continue;
+    }
+    if (current.length > 0 && currentBytes + bytes > targetBatchBytes) {
+      batches.push(current);
+      current = [];
+      currentBytes = 0;
+    }
+    current.push(message);
+    currentBytes += bytes;
   }
+  if (current.length > 0)
+    batches.push(current);
+  return {
+    batches,
+    dropped
+  };
 }
-var init_storage_memory = () => {};
+var encoder;
+var init_batching = __esm(() => {
+  init_dist();
+  init_routing2();
+  encoder = new TextEncoder;
+});
 
-// node_modules/.bun/posthog-node@5.35.12/node_modules/posthog-node/dist/client.mjs
+// node_modules/.bun/posthog-node@5.51.1/node_modules/posthog-node/dist/client.mjs
 function emitDeprecationWarningOnce(id, message) {
   if (_emittedDeprecations.has(id))
     return;
@@ -4593,6 +6346,12 @@ function normalizeHost(value) {
   const normalizedValue = typeof value == "string" ? value.trim() : "";
   return normalizedValue || DEFAULT_NODE_HOST;
 }
+function normalizeUnsetPersonProperties(value) {
+  const propertyNames = Array.isArray(value) ? value : [
+    value
+  ];
+  return propertyNames.filter((propertyName) => typeof propertyName == "string" && propertyName.trim().length > 0);
+}
 function buildFlagEventProperties(flagValues) {
   if (!flagValues)
     return {};
@@ -4613,17 +6372,26 @@ var init_client = __esm(() => {
   init_feature_flags();
   init_error_tracking2();
   init_storage_memory();
+  init_config2();
+  init_routing();
+  init_sender();
+  init_batching();
+  init_routing2();
   _emittedDeprecations = new Set;
   PostHogBackendClient = class PostHogBackendClient extends PostHogCoreStateless {
     constructor(apiKey, options = {}) {
       const normalizedApiKey = normalizeApiKey(apiKey);
       const normalizedOptions = {
         ...options,
+        maxQueueSize: options.maxQueueSize ?? 1e4,
+        flushInterval: options.flushInterval ?? 5000,
         host: normalizeHost(options.host),
-        personalApiKey: normalizePersonalApiKey(options.personalApiKey)
+        personalApiKey: normalizePersonalApiKey(options.secretKey ?? options.personalApiKey)
       };
-      super(normalizedApiKey, normalizedOptions), this._memoryStorage = new PostHogMemoryStorage;
+      super(normalizedApiKey, normalizedOptions), this._memoryStorage = new PostHogMemoryStorage, this._aiCaptureRouteActive = false, this._minimalFlagCalledEvents = false;
       this.options = normalizedOptions;
+      this.captureMode = resolveCaptureMode();
+      this.enableFullAiCapture = normalizedOptions.enableFullAiCapture === true;
       this.context = this.initializeContext();
       this.options.featureFlagsPollingInterval = typeof normalizedOptions.featureFlagsPollingInterval == "number" ? Math.max(normalizedOptions.featureFlagsPollingInterval, MINIMUM_POLLING_INTERVAL) : THIRTY_SECONDS;
       if (typeof normalizedOptions.waitUntilDebounceMs == "number")
@@ -4648,21 +6416,24 @@ var init_client = __esm(() => {
             onLoad: (count) => {
               this._events.emit("localEvaluationFlagsLoaded", count);
             },
+            onMinimalFlagCalledEvents: (enabled) => {
+              this._minimalFlagCalledEvents = enabled;
+            },
             customHeaders: this.getCustomHeaders(),
             cacheProvider: normalizedOptions.flagDefinitionCacheProvider,
             strictLocalEvaluation: normalizedOptions.strictLocalEvaluation
           });
       }
-      this.errorTracking = new ErrorTracking(this, normalizedOptions, this._logger);
+      this.errorTracking = new error_tracking_ErrorTracking(this, normalizedOptions, this._logger);
       this.distinctIdHasSentFlagCalls = {};
       this.maxCacheSize = normalizedOptions.maxCacheSize || MAX_CACHE_SIZE;
     }
-    enqueue(type, message, options) {
-      super.enqueue(type, message, options);
+    enqueue(type, message, options, explicitRoute) {
+      super.enqueue(type, message, options, explicitRoute);
       this.scheduleDebouncedFlush();
     }
     async flush() {
-      const flushPromise = super.flush();
+      const flushPromise = this.flushWithPendingPromises();
       const waitUntil = this.options.waitUntil;
       if (waitUntil && !this._waitUntilCycle)
         try {
@@ -4715,7 +6486,7 @@ var init_client = __esm(() => {
     async resolveWaitUntilFlush() {
       const resolve9 = this._consumeWaitUntilCycle();
       try {
-        await super.flush();
+        await this.flushWithPendingPromises();
       } catch {} finally {
         resolve9?.();
       }
@@ -4729,12 +6500,103 @@ var init_client = __esm(() => {
     fetch(url, options) {
       return this.options.fetch ? this.options.fetch(url, options) : fetch(url, options);
     }
+    getQueueRouteKey(message) {
+      return this.captureMode === "v1" && isLegacyOnlyEvent(message) ? AI_ROUTE : ANALYTICS_ROUTE;
+    }
+    persistedQueueKeyForRoute(route) {
+      if (route === AI_CAPTURE_ROUTE)
+        return types_PostHogPersistedProperty.AiCaptureQueue;
+      return route === AI_ROUTE ? types_PostHogPersistedProperty.AiQueue : types_PostHogPersistedProperty.Queue;
+    }
+    getActiveQueueRoutes() {
+      const routes = this.captureMode === "v1" ? [
+        ANALYTICS_ROUTE,
+        AI_ROUTE
+      ] : [
+        ANALYTICS_ROUTE
+      ];
+      if (this._aiCaptureRouteActive)
+        routes.push(AI_CAPTURE_ROUTE);
+      return routes;
+    }
+    getBatchEndpointPath(route) {
+      return route === AI_CAPTURE_ROUTE ? AI_CAPTURE_ENDPOINT_PATH : super.getBatchEndpointPath(route);
+    }
+    async sendBatch(batchMessages, retryOptions, route = ANALYTICS_ROUTE) {
+      if (route === AI_CAPTURE_ROUTE)
+        return this.sendAiCaptureBatch(batchMessages, retryOptions);
+      if (this.captureMode !== "v1" || route === AI_ROUTE)
+        return super.sendBatch(batchMessages, retryOptions, route);
+      const v1Events = batchMessages.filter((message) => message !== undefined);
+      await this.getV1Sender().sendV1Batch(v1Events);
+    }
+    async sendAiCaptureBatch(batchMessages, retryOptions) {
+      const { batches, dropped } = partitionAiBatch(batchMessages);
+      for (const { event, bytes } of dropped) {
+        const message = `Event ${event} (${bytes} bytes) exceeds the ${AI_MAX_EVENT_BYTES / 1048576}MiB limit for ${AI_CAPTURE_ENDPOINT_PATH}, dropping.`;
+        this._logger.error(message);
+        this._events.emit("error", new Error(message));
+      }
+      for (const batch of batches)
+        await this.sendAiSubBatch(batch, retryOptions);
+    }
+    async sendAiSubBatch(batch, retryOptions) {
+      try {
+        await super.sendBatch(batch, retryOptions, AI_CAPTURE_ROUTE);
+      } catch (err) {
+        if (!isPostHogFetchContentTooLargeError(err))
+          throw err;
+        if (batch.length === 1) {
+          const [event] = batch;
+          const eventName = typeof event.event == "string" ? event.event : "unknown";
+          const message = `Event ${eventName} (${eventByteSize(event)} bytes) was rejected with 413 by ${AI_CAPTURE_ENDPOINT_PATH} on its own, dropping.`;
+          this._logger.error(message);
+          this._events.emit("error", new Error(message));
+          return;
+        }
+        const mid = Math.ceil(batch.length / 2);
+        await this.sendAiSubBatch(batch.slice(0, mid), retryOptions);
+        await this.sendAiSubBatch(batch.slice(mid), retryOptions);
+      }
+    }
+    getV1Sender() {
+      if (!this._v1Sender)
+        this._v1Sender = new V1CaptureSender({
+          host: this.host,
+          apiKey: this.apiKey,
+          libraryId: this.getLibraryId(),
+          libraryVersion: this.getLibraryVersion(),
+          userAgent: this.getCustomUserAgent() || undefined,
+          historicalMigration: this.historicalMigration,
+          compressionEnabled: !this.disableCompression,
+          requestTimeoutMs: this.requestTimeout,
+          maxAttempts: (this.options.fetchRetryCount ?? 3) + 1,
+          initialRetryDelayMs: this.options.fetchRetryDelay ?? 3000,
+          isDebug: this.isDebug
+        }, {
+          fetch: (url, fetchOptions) => this.fetch(url, fetchOptions),
+          onError: (error) => this._events.emit("error", error),
+          compress: (payload) => this.compressPayload(payload)
+        });
+      return this._v1Sender;
+    }
     getLibraryVersion() {
       return version;
     }
+    get metrics() {
+      if (!this._metrics)
+        this._metrics = new PostHogMetrics(this, resolveMetricsConfig(this.options.metrics), this._logger);
+      return this._metrics;
+    }
     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();
     }
@@ -4745,33 +6607,69 @@ var init_client = __esm(() => {
       super.debug(enabled);
       this.featureFlagsPoller?.debug(enabled);
     }
-    capture(props) {
+    _warnIfInvalidCapture(props, stringArgumentWarning, exceptionCaptureWarning) {
       if (typeof props == "string")
-        this._logger.warn("Called capture() with a string as the first argument when an object was expected.");
+        this._logger.warn(stringArgumentWarning);
       if (props.event === "$exception" && !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) => {
+        this._logger.warn(exceptionCaptureWarning);
+    }
+    _sendPreparedEvent(type, props, immediate, prepareOptions, explicitRoute) {
+      return this.addPendingPromise(this._prepareEventMessage(props, prepareOptions).then(({ distinctId, event, properties, options }) => {
+        const captureOptions = {
+          timestamp: options.timestamp,
+          disableGeoip: options.disableGeoip,
+          uuid: options.uuid
+        };
+        const message = {
+          distinctId,
+          event,
+          properties: {
+            ...properties,
+            ...this.getCommonEventProperties()
+          }
+        };
+        return immediate ? this.sendImmediate(type, message, captureOptions, explicitRoute) : this.enqueue(type, message, captureOptions, explicitRoute);
+      }).catch((err) => {
         if (err)
           console.error(err);
       }));
     }
+    _capturePreparedEvent(props, immediate) {
+      return this._sendPreparedEvent("capture", props, immediate);
+    }
+    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 (typeof props == "string")
-        this._logger.warn("Called captureImmediate() with a string as the first argument when an object was expected.");
-      if (props.event === "$exception" && !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);
+    }
+    captureAi(props) {
+      if (this.disabled)
+        return;
+      const uuid = getEventUuid(props.uuid, uuidv7);
+      this._sendPreparedAiEvent({
+        ...props,
+        uuid
+      }, false);
+      return uuid;
+    }
+    async captureAiImmediate(props) {
+      if (this.disabled)
+        return;
+      const uuid = getEventUuid(props.uuid, uuidv7);
+      await this._sendPreparedAiEvent({
+        ...props,
+        uuid
+      }, true);
+      return uuid;
+    }
+    _sendPreparedAiEvent(props, immediate) {
+      if (typeof props?.event == "string" && !props.event.startsWith("$ai_"))
+        this._logger.debug(`captureAi called with non-AI event ${props.event}; routing it to the AI endpoint anyway.`);
+      this._aiCaptureRouteActive = true;
+      return this._sendPreparedEvent("capture", props, immediate, undefined, AI_CAPTURE_ROUTE);
     }
     identify({ distinctId, properties = {}, disableGeoip }) {
       const { $set, $set_once, $anon_distinct_id, ...rest } = properties;
@@ -4782,8 +6680,13 @@ var init_client = __esm(() => {
         $set_once: setOnceProps,
         $anon_distinct_id: $anon_distinct_id ?? undefined
       };
-      super.identifyStateless(distinctId, eventProperties, {
+      this._sendPreparedEvent("identify", {
+        distinctId,
+        event: "$identify",
+        properties: eventProperties,
         disableGeoip
+      }, false, {
+        includeContextProperties: false
       });
     }
     async identifyImmediate({ distinctId, properties = {}, disableGeoip }) {
@@ -4795,18 +6698,65 @@ var init_client = __esm(() => {
         $set_once: setOnceProps,
         $anon_distinct_id: $anon_distinct_id ?? undefined
       };
-      await super.identifyStatelessImmediate(distinctId, eventProperties, {
+      await this._sendPreparedEvent("identify", {
+        distinctId,
+        event: "$identify",
+        properties: eventProperties,
         disableGeoip
+      }, true, {
+        includeContextProperties: false
+      });
+    }
+    setPersonProperties({ distinctId, properties = {}, propertiesOnce = {} }) {
+      if (Object.keys(properties).length === 0 && Object.keys(propertiesOnce).length === 0)
+        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 (propertyNames.length === 0)
+        return;
+      this.capture({
+        distinctId,
+        event: "$set",
+        properties: {
+          $unset: propertyNames
+        }
       });
     }
     alias(data) {
-      super.aliasStateless(data.alias, data.distinctId, undefined, {
+      this._sendPreparedEvent("alias", {
+        distinctId: data.distinctId,
+        event: "$create_alias",
+        properties: {
+          distinct_id: data.distinctId,
+          alias: data.alias
+        },
         disableGeoip: data.disableGeoip
+      }, false, {
+        includeContextProperties: false
       });
     }
     async aliasImmediate(data) {
-      await super.aliasStatelessImmediate(data.alias, data.distinctId, undefined, {
+      await this._sendPreparedEvent("alias", {
+        distinctId: data.distinctId,
+        event: "$create_alias",
+        properties: {
+          distinct_id: data.distinctId,
+          alias: data.alias
+        },
         disableGeoip: data.disableGeoip
+      }, true, {
+        includeContextProperties: false
       });
     }
     isLocalEvaluationReady() {
@@ -4861,7 +6811,7 @@ var init_client = __esm(() => {
       const adjustedProperties = this.addLocalPersonAndGroupProperties(distinctId, groups, personProperties, groupProperties);
       personProperties = adjustedProperties.allPersonProperties;
       groupProperties = adjustedProperties.allGroupProperties;
-      const evaluationContext = this.createFeatureFlagEvaluationContext(distinctId, groups, personProperties, groupProperties);
+      const evaluationContext = this.createFeatureFlagEvaluationContext(distinctId, groups, this.personPropertiesForLocalEvaluation(distinctId, personProperties), groupProperties);
       if (onlyEvaluateLocally == undefined)
         onlyEvaluateLocally = this.options.strictLocalEvaluation ?? false;
       let result;
@@ -4872,6 +6822,7 @@ var init_client = __esm(() => {
       let flagId;
       let flagVersion;
       let flagReason;
+      let flagHasExperiment;
       const localEvaluationEnabled = this.featureFlagsPoller !== undefined;
       if (localEvaluationEnabled) {
         await this.featureFlagsPoller?.loadFeatureFlags();
@@ -4886,6 +6837,7 @@ var init_client = __esm(() => {
               const value = localResult.value;
               flagId = flag.id;
               flagReason = "Evaluated locally";
+              flagHasExperiment = flag.has_experiment;
               result = {
                 key,
                 enabled: value !== false,
@@ -4901,12 +6853,13 @@ var init_client = __esm(() => {
           }
       }
       if (!flagWasLocallyEvaluated && !onlyEvaluateLocally) {
-        const flagsResponse = await super.getFeatureFlagDetailsStateless(evaluationContext.distinctId, evaluationContext.groups, evaluationContext.personProperties, evaluationContext.groupProperties, disableGeoip, [
+        const flagsResponse = await super.getFeatureFlagDetailsStateless(evaluationContext.distinctId, evaluationContext.groups, personProperties, groupProperties, disableGeoip, [
           key
         ]);
         if (flagsResponse === undefined)
           featureFlagError = FeatureFlagError2.UNKNOWN_ERROR;
         else {
+          this._minimalFlagCalledEvents = flagsResponse.minimalFlagCalledEvents === true;
           requestId = flagsResponse.requestId;
           evaluatedAt = flagsResponse.evaluatedAt;
           const errors = [];
@@ -4921,6 +6874,7 @@ var init_client = __esm(() => {
             flagId = flagDetail.metadata?.id;
             flagVersion = flagDetail.metadata?.version;
             flagReason = flagDetail.reason?.description ?? flagDetail.reason?.code;
+            flagHasExperiment = flagDetail.metadata?.has_experiment;
             let parsedPayload;
             if (flagDetail.metadata?.payload !== undefined)
               try {
@@ -4931,7 +6885,7 @@ var init_client = __esm(() => {
             result = {
               key,
               enabled: flagDetail.enabled,
-              variant: flagDetail.variant,
+              variant: flagDetail.variant ?? undefined,
               payload: parsedPayload
             };
           }
@@ -4952,6 +6906,8 @@ var init_client = __esm(() => {
           $feature_flag_request_id: requestId,
           $feature_flag_evaluated_at: flagWasLocallyEvaluated ? Date.now() : evaluatedAt
         };
+        if (flagHasExperiment !== undefined)
+          properties.$feature_flag_has_experiment = flagHasExperiment;
         if (flagWasLocallyEvaluated && this.featureFlagsPoller) {
           const flagDefinitionsLoadedAt = this.featureFlagsPoller.getFlagDefinitionsLoadedAt();
           if (flagDefinitionsLoadedAt !== undefined)
@@ -5066,7 +7022,7 @@ var init_client = __esm(() => {
       const adjustedProperties = this.addLocalPersonAndGroupProperties(resolvedDistinctId, groups, personProperties, groupProperties);
       personProperties = adjustedProperties.allPersonProperties;
       groupProperties = adjustedProperties.allGroupProperties;
-      const evaluationContext = this.createFeatureFlagEvaluationContext(resolvedDistinctId, groups, personProperties, groupProperties);
+      const evaluationContext = this.createFeatureFlagEvaluationContext(resolvedDistinctId, groups, this.personPropertiesForLocalEvaluation(resolvedDistinctId, personProperties), groupProperties);
       if (onlyEvaluateLocally == undefined)
         onlyEvaluateLocally = this.options.strictLocalEvaluation ?? false;
       const localEvaluationResult = await this.featureFlagsPoller?.getAllFlagsAndPayloads(evaluationContext, flagKeys);
@@ -5079,7 +7035,7 @@ var init_client = __esm(() => {
         fallbackToFlags = localEvaluationResult.fallbackToFlags;
       }
       if (fallbackToFlags && !onlyEvaluateLocally) {
-        const remoteEvaluationResult = await super.getFeatureFlagsAndPayloadsStateless(evaluationContext.distinctId, evaluationContext.groups, evaluationContext.personProperties, evaluationContext.groupProperties, disableGeoip, flagKeys);
+        const remoteEvaluationResult = await super.getFeatureFlagsAndPayloadsStateless(evaluationContext.distinctId, evaluationContext.groups, personProperties, groupProperties, disableGeoip, flagKeys);
         featureFlags = {
           ...featureFlags,
           ...remoteEvaluationResult.flags || {}
@@ -5127,9 +7083,10 @@ var init_client = __esm(() => {
       const adjustedProperties = this.addLocalPersonAndGroupProperties(resolvedDistinctId, groups, personProperties, groupProperties);
       personProperties = adjustedProperties.allPersonProperties;
       groupProperties = adjustedProperties.allGroupProperties;
-      const evaluationContext = this.createFeatureFlagEvaluationContext(resolvedDistinctId, groups, personProperties, groupProperties);
+      const evaluationContext = this.createFeatureFlagEvaluationContext(resolvedDistinctId, groups, this.personPropertiesForLocalEvaluation(resolvedDistinctId, personProperties), groupProperties);
       if (onlyEvaluateLocally == undefined)
         onlyEvaluateLocally = this.options.strictLocalEvaluation ?? false;
+      const requestedFlagKeys = flagKeys ? new Set(flagKeys) : undefined;
       const records = {};
       let requestId;
       let evaluatedAt;
@@ -5148,14 +7105,17 @@ var init_client = __esm(() => {
             id: flagDef?.id,
             version: undefined,
             reason: "Evaluated locally",
-            locallyEvaluated: true
+            locallyEvaluated: true,
+            hasExperiment: flagDef?.has_experiment
           };
           locallyEvaluatedKeys.add(key);
         }
-      const fallbackToFlags = localResult ? localResult.fallbackToFlags : true;
+      const requestedFlagMissingLocally = requestedFlagKeys !== undefined && Array.from(requestedFlagKeys).some((key) => this.featureFlagsPoller?.featureFlagsByKey[key] === undefined);
+      const fallbackToFlags = localResult ? localResult.fallbackToFlags || requestedFlagMissingLocally : true;
       if (fallbackToFlags && !onlyEvaluateLocally) {
-        const details = await super.getFeatureFlagDetailsStateless(evaluationContext.distinctId, evaluationContext.groups, evaluationContext.personProperties, evaluationContext.groupProperties, disableGeoip, flagKeys);
+        const details = await super.getFeatureFlagDetailsStateless(evaluationContext.distinctId, evaluationContext.groups, personProperties, groupProperties, disableGeoip, flagKeys);
         if (details) {
+          this._minimalFlagCalledEvents = details.minimalFlagCalledEvents === true;
           requestId = details.requestId;
           evaluatedAt = details.evaluatedAt;
           errorsWhileComputing = Boolean(details.errorsWhileComputingFlags);
@@ -5178,7 +7138,8 @@ var init_client = __esm(() => {
               id: detail.metadata?.id,
               version: detail.metadata?.version,
               reason: detail.reason?.description ?? detail.reason?.code,
-              locallyEvaluated: false
+              locallyEvaluated: false,
+              hasExperiment: detail.metadata?.has_experiment
             };
           }
         }
@@ -5198,7 +7159,8 @@ var init_client = __esm(() => {
             id: existing?.id,
             version: existing?.version,
             reason: existing?.reason,
-            locallyEvaluated: existing?.locallyEvaluated ?? false
+            locallyEvaluated: existing?.locallyEvaluated ?? false,
+            hasExperiment: existing?.hasExperiment
           };
         }
       if (this._payloadOverrides !== undefined)
@@ -5210,6 +7172,11 @@ var init_client = __esm(() => {
               payload
             };
         }
+      if (requestedFlagKeys !== undefined) {
+        for (const key of Object.keys(records))
+          if (!requestedFlagKeys.has(key))
+            delete records[key];
+      }
       return new FeatureFlagEvaluations({
         host: this._getFeatureFlagEvaluationsHost(),
         distinctId: resolvedDistinctId,
@@ -5223,6 +7190,9 @@ var init_client = __esm(() => {
         quotaLimited
       });
     }
+    _shouldSendMinimalFlagCalledEvent(event, properties) {
+      return event === "$feature_flag_called" && this._minimalFlagCalledEvents && properties.$feature_flag_has_experiment === false;
+    }
     _captureFlagCalledEventIfNeeded(params) {
       const { distinctId, key, response, groups, disableGeoip, properties } = params;
       const groupSuffix = groups && Object.keys(groups).length > 0 ? `_${JSON.stringify(Object.entries(groups).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0))}` : "";
@@ -5257,9 +7227,32 @@ var init_client = __esm(() => {
       return this._featureFlagEvaluationsHost;
     }
     groupIdentify({ groupType, groupKey, properties, distinctId, disableGeoip }) {
-      super.groupIdentifyStateless(groupType, groupKey, properties, {
+      this._sendPreparedEvent("capture", {
+        distinctId: distinctId || `$${groupType}_${groupKey}`,
+        event: "$groupidentify",
+        properties: {
+          $group_type: groupType,
+          $group_key: groupKey,
+          $group_set: properties || {}
+        },
+        disableGeoip
+      }, false, {
+        includeContextProperties: false
+      });
+    }
+    async groupIdentifyImmediate({ groupType, groupKey, properties, distinctId, disableGeoip }) {
+      await this._sendPreparedEvent("capture", {
+        distinctId: distinctId || `$${groupType}_${groupKey}`,
+        event: "$groupidentify",
+        properties: {
+          $group_type: groupType,
+          $group_key: groupKey,
+          $group_set: properties || {}
+        },
         disableGeoip
-      }, distinctId);
+      }, true, {
+        includeContextProperties: false
+      });
     }
     async reloadFeatureFlags() {
       await this.featureFlagsPoller?.loadFeatureFlags(true);
@@ -5331,12 +7324,18 @@ var init_client = __esm(() => {
       this.context?.enter(data, options);
     }
     async _shutdown(shutdownTimeoutMs) {
+      const shutdownDeadlineMs = Date.now() + (shutdownTimeoutMs ?? 30000);
       const resolve9 = this._consumeWaitUntilCycle();
       await this.featureFlagsPoller?.stopPoller(shutdownTimeoutMs);
       this.errorTracking.shutdown();
+      if (this._metrics) {
+        await raceWithTimeout(this._metrics.flush().catch(() => {}), Math.max(0, shutdownDeadlineMs - Date.now()));
+        this._metrics.reset();
+      }
       try {
-        return await super._shutdown(shutdownTimeoutMs);
+        return await super._shutdown(Math.max(0, shutdownDeadlineMs - Date.now()));
       } finally {
+        this.distinctIdHasSentFlagCalls = {};
         resolve9?.();
       }
     }
@@ -5431,7 +7430,6 @@ var init_client = __esm(() => {
     }
     addLocalPersonAndGroupProperties(distinctId, groups, personProperties, groupProperties) {
       const allPersonProperties = {
-        distinct_id: distinctId,
         ...personProperties || {}
       };
       const allGroupProperties = {};
@@ -5446,6 +7444,12 @@ var init_client = __esm(() => {
         allGroupProperties
       };
     }
+    personPropertiesForLocalEvaluation(distinctId, personProperties) {
+      return {
+        distinct_id: distinctId,
+        ...personProperties || {}
+      };
+    }
     createFeatureFlagEvaluationContext(distinctId, groups, personProperties, groupProperties) {
       return {
         distinctId,
@@ -5456,21 +7460,21 @@ var init_client = __esm(() => {
       };
     }
     captureException(error, distinctId, additionalProperties, uuid, flags) {
-      if (!ErrorTracking.isPreviouslyCapturedError(error)) {
+      if (!error_tracking_ErrorTracking.isPreviouslyCapturedError(error)) {
         const syntheticException = new Error("PostHog syntheticException");
-        this.addPendingPromise(ErrorTracking.buildEventMessage(this.getErrorPropertiesBuilder(), error, {
+        this.addPendingPromise(error_tracking_ErrorTracking.buildEventMessage(this.getErrorPropertiesBuilder(), error, {
           syntheticException
-        }, distinctId, additionalProperties).then((msg) => this.capture({
+        }, distinctId, additionalProperties).then((msg) => this._capturePreparedEvent({
           ...msg,
           uuid,
           flags
-        })));
+        }, false)));
       }
     }
     async captureExceptionImmediate(error, distinctId, additionalProperties, flags) {
-      if (!ErrorTracking.isPreviouslyCapturedError(error)) {
+      if (!error_tracking_ErrorTracking.isPreviouslyCapturedError(error)) {
         const syntheticException = new Error("PostHog syntheticException");
-        return this.addPendingPromise(ErrorTracking.buildEventMessage(this.getErrorPropertiesBuilder(), error, {
+        return this.addPendingPromise(error_tracking_ErrorTracking.buildEventMessage(this.getErrorPropertiesBuilder(), error, {
           syntheticException
         }, distinctId, additionalProperties).then((msg) => this.captureImmediate({
           ...msg,
@@ -5479,24 +7483,31 @@ var init_client = __esm(() => {
       }
     }
     async prepareEventMessage(props) {
+      return this._prepareEventMessage(props);
+    }
+    async _prepareEventMessage(props, options = {}) {
       const { distinctId, event, properties, groups, flags, sendFeatureFlags, timestamp, disableGeoip, uuid } = props;
       const contextData = this.context?.get();
+      const includeContextProperties = options.includeContextProperties ?? true;
       let mergedDistinctId = distinctId || contextData?.distinctId;
-      const mergedProperties = {
+      const mergedProperties = includeContextProperties ? {
         ...this.props,
         ...contextData?.properties || {},
         ...properties || {}
+      } : {
+        ...properties || {}
       };
       if (!mergedDistinctId) {
         mergedDistinctId = uuidv7();
         mergedProperties.$process_person_profile = false;
       }
-      if (contextData?.sessionId && !mergedProperties.$session_id)
+      if (includeContextProperties && contextData?.sessionId && !mergedProperties.$session_id)
         mergedProperties.$session_id = contextData.sessionId;
+      const finalProperties = this._shouldSendMinimalFlagCalledEvent(event, mergedProperties) ? minimizeFlagCalledEventProperties(mergedProperties) : mergedProperties;
       const eventMessage = this._runBeforeSend({
         distinctId: mergedDistinctId,
         event,
-        properties: mergedProperties,
+        properties: finalProperties,
         groups,
         flags,
         sendFeatureFlags,
@@ -5520,12 +7531,14 @@ var init_client = __esm(() => {
         }
         return {};
       }).catch(() => ({})).then((additionalProperties) => {
-        const props2 = {
+        const resolvedGroups = eventMessage.groups || groups;
+        return {
           ...additionalProperties,
           ...eventMessage.properties || {},
-          $groups: eventMessage.groups || groups
+          ...resolvedGroups !== undefined && Object.keys(resolvedGroups).length > 0 ? {
+            $groups: resolvedGroups
+          } : {}
         };
-        return props2;
       });
       if (eventMessage.event === "$pageview" && this.options.__preview_capture_bot_pageviews && typeof eventProperties.$raw_user_agent == "string") {
         if (isBlockedUA(eventProperties.$raw_user_agent, this.options.custom_blocked_useragents || [])) {
@@ -5552,23 +7565,27 @@ var init_client = __esm(() => {
         beforeSend
       ];
       let result = eventMessage;
-      for (const fn of fns) {
-        result = fn(result);
-        if (!result) {
-          this._logger.info(`Event '${eventMessage.event}' was rejected in beforeSend function`);
+      for (const fn of fns)
+        try {
+          result = fn(result);
+          if (!result) {
+            this._logger.info(`Event '${eventMessage.event}' was rejected in beforeSend function`);
+            return null;
+          }
+          if (!result.properties || Object.keys(result.properties).length === 0) {
+            const message = `Event '${result.event}' has no properties after beforeSend function, this is likely an error.`;
+            this._logger.warn(message);
+          }
+        } catch (error) {
+          this._logger.error(`Error in before_send function for event '${eventMessage.event}':`, error);
           return null;
         }
-        if (!result.properties || Object.keys(result.properties).length === 0) {
-          const message = `Event '${result.event}' has no properties after beforeSend function, this is likely an error.`;
-          this._logger.warn(message);
-        }
-      }
       return result;
     }
   };
 });
 
-// node_modules/.bun/posthog-node@5.35.12/node_modules/posthog-node/dist/extensions/context/context.mjs
+// node_modules/.bun/posthog-node@5.51.1/node_modules/posthog-node/dist/extensions/context/context.mjs
 import { AsyncLocalStorage } from "node:async_hooks";
 
 class PostHogContext {
@@ -5600,7 +7617,25 @@ class PostHogContext {
 }
 var init_context = () => {};
 
-// node_modules/.bun/posthog-node@5.35.12/node_modules/posthog-node/dist/extensions/sentry-integration.mjs
+// node_modules/.bun/posthog-node@5.51.1/node_modules/posthog-node/dist/gzip.node.mjs
+import { gzip } from "node:zlib";
+import { promisify } from "node:util";
+async function gzipCompress2(input, isDebug = true) {
+  try {
+    const compressed = await gzipAsync(input);
+    return new Uint8Array(compressed);
+  } catch (error) {
+    if (isDebug)
+      console.error("Failed to gzip compress data", error);
+    return null;
+  }
+}
+var gzipAsync;
+var init_gzip_node = __esm(() => {
+  gzipAsync = promisify(gzip);
+});
+
+// node_modules/.bun/posthog-node@5.51.1/node_modules/posthog-node/dist/extensions/sentry-integration.mjs
 function createEventProcessor(_posthog, { organization, projectId, prefix, severityAllowList = [
   "error"
 ], sendExceptionsToPostHog = true } = {}) {
@@ -5639,6 +7674,9 @@ function createEventProcessor(_posthog, { organization, projectId, prefix, sever
       $sentry_exception_type: exceptions[0]?.type,
       $sentry_tags: event.tags
     };
+    const injectedReleaseId = exports_error_tracking.getInjectedReleaseId();
+    if (injectedReleaseId)
+      properties.$release_id = injectedReleaseId;
     if (organization && projectId)
       properties["$sentry_url"] = (prefix || "https://sentry.io/organizations/") + organization + "/issues/?project=" + projectId + "&query=" + event.event_id;
     if (sendExceptionsToPostHog)
@@ -5652,6 +7690,7 @@ function createEventProcessor(_posthog, { organization, projectId, prefix, sever
 }
 var NAME = "posthog-node", PostHogSentryIntegration;
 var init_sentry_integration = __esm(() => {
+  init_dist();
   PostHogSentryIntegration = class PostHogSentryIntegration {
     static #_ = this.POSTHOG_ID_TAG = "posthog_distinct_id";
     constructor(_posthog, organization, prefix, severityAllowList, sendExceptionsToPostHog) {
@@ -5671,16 +7710,22 @@ var init_sentry_integration = __esm(() => {
   };
 });
 
-// node_modules/.bun/posthog-node@5.35.12/node_modules/posthog-node/dist/extensions/tracing-headers.mjs
+// node_modules/.bun/posthog-node@5.51.1/node_modules/posthog-node/dist/extensions/tracing-headers.mjs
 var init_tracing_headers2 = () => {};
 
-// node_modules/.bun/posthog-node@5.35.12/node_modules/posthog-node/dist/extensions/express.mjs
+// node_modules/.bun/posthog-node@5.51.1/node_modules/posthog-node/dist/extensions/url-utils.mjs
+var init_url_utils = __esm(() => {
+  init_dist();
+});
+
+// node_modules/.bun/posthog-node@5.51.1/node_modules/posthog-node/dist/extensions/express.mjs
 var init_express = __esm(() => {
   init_error_tracking2();
   init_tracing_headers2();
+  init_url_utils();
 });
 
-// node_modules/.bun/posthog-node@5.35.12/node_modules/posthog-node/dist/exports.mjs
+// node_modules/.bun/posthog-node@5.51.1/node_modules/posthog-node/dist/exports.mjs
 var init_exports = __esm(() => {
   init_feature_flag_evaluations();
   init_dist();
@@ -5689,7 +7734,7 @@ var init_exports = __esm(() => {
   init_types3();
 });
 
-// node_modules/.bun/posthog-node@5.35.12/node_modules/posthog-node/dist/entrypoints/index.node.mjs
+// node_modules/.bun/posthog-node@5.51.1/node_modules/posthog-node/dist/entrypoints/index.node.mjs
 var PostHog;
 var init_index_node = __esm(() => {
   init_module_node();
@@ -5698,11 +7743,15 @@ var init_index_node = __esm(() => {
   init_client();
   init_dist();
   init_context();
+  init_gzip_node();
   init_exports();
   PostHog = class PostHog extends PostHogBackendClient {
     getLibraryId() {
       return "posthog-node";
     }
+    compressPayload(payload) {
+      return gzipCompress2(payload, this.isDebug);
+    }
     initializeContext() {
       return new PostHogContext;
     }
@@ -5715,13 +7764,24 @@ var init_index_node = __esm(() => {
         new exports_error_tracking.PrimitiveCoercer
       ], exports_error_tracking.createStackParser("node:javascript", exports_error_tracking.nodeStackLineParser), [
         createModulerModifier(),
-        addSourceContext,
+        (frames) => addSourceContext(frames, undefined, this._logger),
         createRelativePathModifier()
       ]);
     }
   };
 });
 
+// packages/telemetry-core/src/machine-id.ts
+import { createHash as createHash3 } from "node:crypto";
+import os2 from "node:os";
+function getDefaultTelemetryOsProvider() {
+  return os2;
+}
+function getTelemetryDistinctId(machineIdPrefix, osProvider = getDefaultTelemetryOsProvider()) {
+  return createHash3("sha256").update(`${machineIdPrefix}${osProvider.hostname()}`).digest("hex");
+}
+var init_machine_id = () => {};
+
 // packages/telemetry-core/src/posthog-client.ts
 class PostHogTelemetryTransport {
   #client;
@@ -5743,7 +7803,7 @@ function createDefaultPostHogTransport(apiKey, options) {
 }
 function isTelemetryClientEnabled(input) {
   const env = input.env ?? process.env;
-  return !shouldDisableTelemetry({ env, productEnvPrefix: input.product.productEnvPrefix }) && getTelemetryApiKey(env, input.product.defaultApiKey).length > 0;
+  return !shouldDisableTelemetry({ env, productEnvPrefix: input.product.productEnvPrefix }) && hasTelemetryApiKey(env, input.product.defaultApiKey);
 }
 function createTelemetryClient(input) {
   if (!isTelemetryClientEnabled(input)) {
@@ -5809,7 +7869,8 @@ function createTransport(input) {
       flushAt: 1,
       flushInterval: 0,
       host: getTelemetryHost(env, input.product.defaultHost),
-      disableGeoip: false
+      disableGeoip: input.product.disableGeoip ?? false,
+      ...input.product.transportOptions
     });
   } catch (error) {
     input.diagnostics?.({
@@ -5886,6 +7947,17 @@ var init_posthog_client = __esm(() => {
   };
 });
 
+// packages/telemetry-core/src/events.ts
+var ALLOWED_DOLLAR_KEYS;
+var init_events = __esm(() => {
+  ALLOWED_DOLLAR_KEYS = new Set([
+    "$os",
+    "$os_version",
+    "$process_person_profile",
+    "$session_id"
+  ]);
+});
+
 // packages/telemetry-core/src/record-daily-active.ts
 var init_record_daily_active = () => {};
 
@@ -5894,6 +7966,7 @@ var init_src = __esm(() => {
   init_activity_state();
   init_diagnostics();
   init_env();
+  init_events();
   init_machine_id();
   init_posthog_client();
   init_record_daily_active();
@@ -5904,7 +7977,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@oh-my-opencode/omo-codex",
-    version: "5.0.0-beta.3",
+    version: "5.0.0-beta.30",
     type: "module",
     private: true,
     description: "Codex harness adapter for oh-my-openagent. Vendored Codex plugin namespace (omo) + TypeScript installer + telemetry.",
@@ -5938,7 +8011,7 @@ var init_package = __esm(() => {
       "@oh-my-opencode/utils": "workspace:*"
     },
     devDependencies: {
-      "bun-types": "1.3.14"
+      "bun-types": "1.4.0"
     }
   };
 });
@@ -6109,14 +8182,14 @@ var init_posthog = __esm(() => {
 // packages/omo-codex/src/telemetry/index.ts
 var exports_telemetry = {};
 __export(exports_telemetry, {
-  getPostHogDistinctId: () => getPostHogDistinctId,
-  createPluginPostHog: () => createPluginPostHog,
-  createInstallPostHog: () => createInstallPostHog,
-  createCliPostHog: () => createCliPostHog,
-  __setOsProviderForTesting: () => __setOsProviderForTesting,
-  __setActivityStateProviderForTesting: () => __setActivityStateProviderForTesting,
+  __resetActivityStateProviderForTesting: () => __resetActivityStateProviderForTesting,
   __resetOsProviderForTesting: () => __resetOsProviderForTesting,
-  __resetActivityStateProviderForTesting: () => __resetActivityStateProviderForTesting
+  __setActivityStateProviderForTesting: () => __setActivityStateProviderForTesting,
+  __setOsProviderForTesting: () => __setOsProviderForTesting,
+  createCliPostHog: () => createCliPostHog,
+  createInstallPostHog: () => createInstallPostHog,
+  createPluginPostHog: () => createPluginPostHog,
+  getPostHogDistinctId: () => getPostHogDistinctId
 });
 var init_telemetry = __esm(() => {
   init_posthog();
@@ -6124,7 +8197,7 @@ var init_telemetry = __esm(() => {
 
 // packages/omo-codex/src/install/install-local-cli.ts
 import { readFile as readFile23 } from "node:fs/promises";
-import { dirname as dirname12, join as join40, resolve as resolve10 } from "node:path";
+import { dirname as dirname13, join as join40, resolve as resolve10 } from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 
 // packages/utils/src/runtime/spawn.ts
@@ -6624,9 +8697,9 @@ var LEGACY_CODEX_COMPONENT_BINS = [
   { name: "codex-comment-checker", component: "comment-checker" },
   { name: "codex-lsp", component: "lsp" },
   { name: "codex-rules", component: "rules" },
-  { name: "codex-start-work-continuation", component: "start-work-continuation" },
   { name: "codex-telemetry", component: "telemetry" },
-  { name: "codex-ultrawork", component: "ultrawork" }
+  { name: "codex-ultrawork", component: "ultrawork" },
+  { name: "codex-ulw-execute-continuation", component: "ulw-execute-continuation" }
 ];
 var LEGACY_CODEX_COMPONENT_BIN_NAMES = LEGACY_CODEX_COMPONENT_BINS.map((entry) => entry.name);
 async function removeLegacyCodexComponentBins(binDir, platform) {
@@ -8971,14 +11044,14 @@ import { join as join17 } from "node:path";
 var FALLBACK_CODEX_MODEL_CATALOG = {
   current: {
     model: "gpt-5.6-sol",
-    modelContextWindow: 372000,
+    modelContextWindow: 650000,
     modelReasoningEffort: "high",
     planModeReasoningEffort: "xhigh"
   },
   managedProfiles: [
     {
       model: "gpt-5.5",
-      modelContextWindow: 400000,
+      modelContextWindow: 650000,
       modelReasoningEffort: "high",
       planModeReasoningEffort: "xhigh"
     },
@@ -10796,6 +12869,7 @@ function runtimeSlug(platform = process.platform, arch = process.arch) {
 
 // packages/utils/src/ast-grep/install-script.ts
 var AST_GREP_BIN_DIR_ENV_KEY = "OMO_AST_GREP_BIN_DIR";
+var KILL_GRACE_MS = 1000;
 var AST_GREP_INSTALL_TIMEOUT_MS = 30000;
 function astGrepRuntimeDir(baseDir, platform = process.platform, arch = process.arch) {
   return join32(baseDir, "runtime", "ast-grep", runtimeSlug(platform, arch));
@@ -10847,16 +12921,30 @@ function invocationsForPlatform(scriptPath, platform) {
 async function runInvocation(input) {
   const child = input.spawnProcess(input.invocation.command, input.invocation.args, { cwd: input.skillDir, env: input.env });
   let timedOut = false;
+  let terminateDeadline;
+  let terminateDeadlineGrace;
+  const killIgnored = new Promise((_, reject) => {
+    terminateDeadline = () => reject(new Error("ast-grep install child ignored termination"));
+  });
   const timeout = setTimeout(() => {
     timedOut = true;
     child.kill();
+    terminateDeadlineGrace = setTimeout(() => terminateDeadline?.(), KILL_GRACE_MS);
   }, input.timeoutMs);
-  timeout.unref?.();
   try {
-    const outcome = await child.outcome;
-    return timedOut ? { kind: "timed-out" } : outcome;
+    const outcome = await Promise.race([child.outcome, killIgnored]);
+    if (timedOut)
+      return { kind: "timed-out" };
+    return outcome;
+  } catch (error) {
+    if (error instanceof Error && error.message.includes("ignored termination")) {
+      return { kind: "spawn-error", error, missingExecutable: false };
+    }
+    throw error;
   } finally {
     clearTimeout(timeout);
+    if (terminateDeadlineGrace !== undefined)
+      clearTimeout(terminateDeadlineGrace);
   }
 }
 function failedReason(outcome) {
@@ -11467,7 +13555,7 @@ function shellQuote(value) {
 // packages/omo-codex/src/install/lazycodex-manual-update.ts
 import { spawn as spawn3, spawnSync as spawnSync3 } from "node:child_process";
 import { readFileSync as readFileSync4 } from "node:fs";
-import { dirname as dirname11, join as join38 } from "node:path";
+import { dirname as dirname12, join as join38 } from "node:path";
 import { createInterface as createInterface2 } from "node:readline/promises";
 import { fileURLToPath } from "node:url";
 
@@ -11576,7 +13664,7 @@ function resolveArgs(env2) {
 function resolveCurrentVersion(env2) {
   if (env2.LAZYCODEX_CURRENT_VERSION?.trim())
     return env2.LAZYCODEX_CURRENT_VERSION.trim();
-  const pluginRoot = dirname11(dirname11(fileURLToPath(import.meta.url)));
+  const pluginRoot = dirname12(dirname12(fileURLToPath(import.meta.url)));
   return readVersionManifest(resolveInstalledVersionPath(env2, pluginRoot)) ?? readVersionManifest(join38(pluginRoot, "..", "..", "..", "package.json")) ?? readVersionManifest(join38(pluginRoot, ".codex-plugin", "plugin.json"));
 }
 function resolveLatestVersion(env2) {
@@ -11756,7 +13844,7 @@ async function installMarketplaceLocally(options = {}) {
   return runCodexInstaller(options);
 }
 function resolveDefaultRepoRootForEntrypoint(entrypointPath) {
-  return resolve10(dirname12(entrypointPath), "..", "..", "..");
+  return resolve10(dirname13(entrypointPath), "..", "..", "..");
 }
 function resolveDefaultRepoRoot() {
   return resolveDefaultRepoRootForEntrypoint(fileURLToPath2(import.meta.url));
@@ -11809,23 +13897,23 @@ async function runLazyCodexInstallLocalCli(input) {
   return 0;
 }
 export {
-  updateCodexConfig,
-  stampGitBashMcpEnv,
-  runLazyCodexInstallLocalCli,
-  runDelegatedOmoCommand,
-  resolveDefaultRepoRootForEntrypoint,
-  resolveDefaultRepoRoot,
-  resolveCodexInstallerBinDir,
-  repairNearestProjectLocalCodexArtifacts,
-  readCodexModelCatalog,
-  parseLazyCodexInstallCliArgs,
-  linkRootRuntimeBin,
-  linkCachedPluginBins,
-  installMarketplaceLocally,
-  installCachedPlugin,
-  formatLazyCodexInstallHelp,
-  findMissingHookCommandTargets,
-  buildDelegatedOmoInvocation,
+  PASSTHROUGH_COMMANDS,
   assertHookCommandTargets,
-  PASSTHROUGH_COMMANDS
+  buildDelegatedOmoInvocation,
+  findMissingHookCommandTargets,
+  formatLazyCodexInstallHelp,
+  installCachedPlugin,
+  installMarketplaceLocally,
+  linkCachedPluginBins,
+  linkRootRuntimeBin,
+  parseLazyCodexInstallCliArgs,
+  readCodexModelCatalog,
+  repairNearestProjectLocalCodexArtifacts,
+  resolveCodexInstallerBinDir,
+  resolveDefaultRepoRoot,
+  resolveDefaultRepoRootForEntrypoint,
+  runDelegatedOmoCommand,
+  runLazyCodexInstallLocalCli,
+  stampGitBashMcpEnv,
+  updateCodexConfig
 };