@vercel/flags-core 1.5.0 → 1.6.0-7d29945-20260616152249

package/dist/{chunk-WTGXBSWR.js → chunk-PSYHUXJC.js}

@@ -50,6 +50,22 @@ var MAX_REGEX_INPUT_LENGTH = 1e4;
 var UINT32_MAX = 4294967295;
 var SCALED_WEIGHTS = /* @__PURE__ */ Symbol("@vercel/flags-core:scaledWeights");
 var COMPILED_REGEX = /* @__PURE__ */ Symbol("@vercel/flags-core:compiledRegex");
+var EVALUATION_VARIANT_INDEX = /* @__PURE__ */ Symbol(
+  "@vercel/flags-core:evaluationVariantIndex"
+);
+function withVariantIndex(value, outcomeType, variantIndex) {
+  return Object.defineProperty(
+    {
+      value,
+      outcomeType
+    },
+    EVALUATION_VARIANT_INDEX,
+    { value: variantIndex }
+  );
+}
+function getEvaluationVariantIndex(result) {
+  return result[EVALUATION_VARIANT_INDEX];
+}
 function getScaledWeights(outcome) {
   const cached = outcome[SCALED_WEIGHTS];
   if (cached) return cached;
@@ -313,10 +329,11 @@ function getVariant(variants, index) {
 }
 function handleOutcome(params, outcome) {
   if (typeof outcome === "number") {
-    return {
-      value: getVariant(params.definition.variants, outcome),
-      outcomeType: "value" /* VALUE */
-    };
+    return withVariantIndex(
+      getVariant(params.definition.variants, outcome),
+      "value" /* VALUE */,
+      outcome
+    );
   }
   switch (outcome.type) {
     case "split": {
@@ -326,15 +343,21 @@ function handleOutcome(params, outcome) {
         outcome.defaultVariant
       );
       if (typeof lhs !== "string") {
-        return { value: defaultOutcome, outcomeType: "split" /* SPLIT */ };
+        return withVariantIndex(
+          defaultOutcome,
+          "split" /* SPLIT */,
+          outcome.defaultVariant
+        );
       }
       const value = hashInput(lhs, params.definition.seed);
       const scaledWeights = getScaledWeights(outcome);
       const variantIndex = findWeightedIndex(scaledWeights, value, UINT32_MAX);
-      return {
-        value: variantIndex === -1 ? defaultOutcome : getVariant(params.definition.variants, variantIndex),
-        outcomeType: "split" /* SPLIT */
-      };
+      const selectedVariantIndex = variantIndex === -1 ? outcome.defaultVariant : variantIndex;
+      return withVariantIndex(
+        selectedVariantIndex === outcome.defaultVariant ? defaultOutcome : getVariant(params.definition.variants, selectedVariantIndex),
+        "split" /* SPLIT */,
+        selectedVariantIndex
+      );
     }
     case "rollout": {
       const lhs = access(outcome.base, params);
@@ -343,18 +366,20 @@ function handleOutcome(params, outcome) {
         outcome.defaultVariant
       );
       if (typeof lhs !== "string") {
-        return { value: defaultOutcome, outcomeType: "rollout" /* ROLLOUT */ };
+        return withVariantIndex(
+          defaultOutcome,
+          "rollout" /* ROLLOUT */,
+          outcome.defaultVariant
+        );
       }
       const now = Date.now();
       const elapsed = now - outcome.startTimestamp;
       if (elapsed < 0 || outcome.slots.length === 0) {
-        return {
-          value: getVariant(
-            params.definition.variants,
-            outcome.rollFromVariant
-          ),
-          outcomeType: "rollout" /* ROLLOUT */
-        };
+        return withVariantIndex(
+          getVariant(params.definition.variants, outcome.rollFromVariant),
+          "rollout" /* ROLLOUT */,
+          outcome.rollFromVariant
+        );
       }
       let cumulativeDuration = 0;
       let currentPromille = 0;
@@ -369,32 +394,27 @@ function handleOutcome(params, outcome) {
       }
       if (exhausted) currentPromille = 1e5;
       if (currentPromille <= 0) {
-        return {
-          value: getVariant(
-            params.definition.variants,
-            outcome.rollFromVariant
-          ),
-          outcomeType: "rollout" /* ROLLOUT */
-        };
+        return withVariantIndex(
+          getVariant(params.definition.variants, outcome.rollFromVariant),
+          "rollout" /* ROLLOUT */,
+          outcome.rollFromVariant
+        );
       }
       if (currentPromille >= 1e5) {
-        return {
-          value: getVariant(
-            params.definition.variants,
-            outcome.rollToVariant
-          ),
-          outcomeType: "rollout" /* ROLLOUT */
-        };
+        return withVariantIndex(
+          getVariant(params.definition.variants, outcome.rollToVariant),
+          "rollout" /* ROLLOUT */,
+          outcome.rollToVariant
+        );
       }
       const value = hashInput(lhs, params.definition.seed);
       const threshold = currentPromille / 1e5 * UINT32_MAX;
-      return {
-        value: value < threshold ? getVariant(params.definition.variants, outcome.rollToVariant) : getVariant(
-          params.definition.variants,
-          outcome.rollFromVariant
-        ),
-        outcomeType: "rollout" /* ROLLOUT */
-      };
+      const selectedVariantIndex = value < threshold ? outcome.rollToVariant : outcome.rollFromVariant;
+      return withVariantIndex(
+        getVariant(params.definition.variants, selectedVariantIndex),
+        "rollout" /* ROLLOUT */,
+        selectedVariantIndex
+      );
     }
     default: {
       const { type } = outcome;
@@ -482,7 +502,7 @@ function findWeightedIndex(weights, value, maxValue) {
 }
 
 // package.json
-var version = "1.5.0";
+var version = "1.6.0-7d29945-20260616152249";
 
 // src/lib/report-value.ts
 function internalReportValue(key, value, data) {
@@ -521,6 +541,14 @@ function getFallbackDatafile(id) {
   if (ds.getFallbackDatafile) return ds.getFallbackDatafile();
   throw new Error("flags: This data source does not support fallbacks");
 }
+function getVariantIdentifier(definition, result) {
+  const variantIndex = getEvaluationVariantIndex(result);
+  if (variantIndex === void 0) return "unknown";
+  return definition.variantIds?.[variantIndex] ?? String(variantIndex);
+}
+function trackEvaluation(controller, options) {
+  controller.trackEvaluation?.(options);
+}
 async function evaluate2(id, flagKey, defaultValue, entities) {
   const controller = getInstance(id).controller;
   let datafile;
@@ -528,11 +556,17 @@ async function evaluate2(id, flagKey, defaultValue, entities) {
     datafile = await controller.read();
   } catch (error) {
     if (defaultValue !== void 0) {
-      return {
+      const result2 = {
         value: defaultValue,
         reason: "error" /* ERROR */,
         errorMessage: error instanceof Error ? error.message : "Failed to read datafile"
       };
+      trackEvaluation(controller, {
+        flagKey,
+        variant: "unknown",
+        reason: result2.reason
+      });
+      return result2;
     }
     throw error;
   }
@@ -545,7 +579,7 @@ async function evaluate2(id, flagKey, defaultValue, entities) {
         reason: "error" /* ERROR */
       });
     }
-    return {
+    const result2 = {
       value: defaultValue,
       reason: "error" /* ERROR */,
       errorCode: "FLAG_NOT_FOUND" /* FLAG_NOT_FOUND */,
@@ -559,6 +593,12 @@ async function evaluate2(id, flagKey, defaultValue, entities) {
         mode: datafile.metrics.mode
       }
     };
+    trackEvaluation(controller, {
+      flagKey,
+      variant: "unknown",
+      reason: result2.reason
+    });
+    return result2;
   }
   const evalStartTime = Date.now();
   const result = evaluate({
@@ -577,6 +617,14 @@ async function evaluate2(id, flagKey, defaultValue, entities) {
       outcomeType: result.reason !== "error" /* ERROR */ ? result.outcomeType : void 0
     });
   }
+  trackEvaluation(controller, {
+    flagKey,
+    variant: getVariantIdentifier(
+      flagDefinition,
+      result
+    ),
+    reason: result.reason
+  });
   return Object.assign(result, {
     metrics: {
       evaluationMs: evaluationDurationMs,
@@ -602,6 +650,11 @@ async function bulkEvaluate2(id, flags, entities) {
         reason: "error" /* ERROR */,
         errorMessage
       };
+      trackEvaluation(controller, {
+        flagKey: flag.key,
+        variant: "unknown",
+        reason: "error" /* ERROR */
+      });
     }
     return results2;
   }
@@ -633,6 +686,11 @@ async function bulkEvaluate2(id, flags, entities) {
         errorMessage: `@vercel/flags-core: Definition not found for flag "${key}"`,
         metrics: { evaluationMs: 0, ...baseMetrics }
       };
+      trackEvaluation(controller, {
+        flagKey: key,
+        variant: "unknown",
+        reason: "error" /* ERROR */
+      });
       continue;
     }
     toEvaluate[key] = { definition: flagDefinition, defaultValue };
@@ -654,6 +712,14 @@ async function bulkEvaluate2(id, flags, entities) {
         outcomeType: result.reason !== "error" /* ERROR */ ? result.outcomeType : void 0
       });
     }
+    trackEvaluation(controller, {
+      flagKey: key,
+      variant: getVariantIdentifier(
+        toEvaluate[key].definition,
+        result
+      ),
+      reason: result.reason
+    });
     results[key] = Object.assign(result, {
       metrics: { evaluationMs: evaluationDurationMs, ...baseMetrics }
     });
@@ -798,8 +864,8 @@ async function readBundledDefinitions(auth) {
   return { definitions: null, state: "missing-entry" };
 }
 
-// src/utils/usage-tracker.ts
-import { waitUntil } from "@vercel/functions";
+// src/utils/ingest.ts
+import { getVercelOidcToken } from "@vercel/oidc";
 
 // src/utils/backoff.ts
 var DEFAULT_BASE_MS = 250;
@@ -810,23 +876,72 @@ function getRetryDelayMs(attempt, options = {}) {
   const ceiling = Math.min(capMs, baseMs * 2 ** Math.max(0, attempt - 1));
   return Math.floor(Math.random() * ceiling);
 }
-function getJitteredWaitMs(baseMs, ratio) {
-  const min = baseMs * (1 - ratio);
-  const span = baseMs * 2 * ratio;
-  return Math.floor(min + Math.random() * span);
-}
 
-// src/utils/usage-tracker.ts
-var RESOLVED_VOID = Promise.resolve();
+// src/utils/ingest.ts
+var MAX_RETRIES = 3;
+var EVALUATING_OIDC_TOKEN_HEADER = "X-Vercel-Flags-Evaluating-OIDC-Token";
 var isDebugMode = process.env.DEBUG?.includes("@vercel/flags-core");
 var debugLog = (...args) => {
   if (!isDebugMode) return;
   console.log(...args);
 };
-var MAX_RETRIES = 3;
-var MAX_BATCH_SIZE = 50;
-var MAX_BATCH_WAIT_MS = 5e3;
-var BATCH_WAIT_JITTER_RATIO = 0.2;
+async function getEvaluatingOidcToken(auth) {
+  if (!auth.sdkKey) return void 0;
+  try {
+    return await getVercelOidcToken();
+  } catch {
+    return void 0;
+  }
+}
+async function getIngestHeaders(options) {
+  const token = await options.auth.resolveToken();
+  const evaluatingOidcToken = await getEvaluatingOidcToken(options.auth);
+  return {
+    "Content-Type": "application/json",
+    Authorization: `Bearer ${token}`,
+    "User-Agent": `VercelFlagsCore/${version}`,
+    ...process.env.VERCEL_ENV ? { "X-Vercel-Env": process.env.VERCEL_ENV } : null,
+    ...evaluatingOidcToken ? { [EVALUATING_OIDC_TOKEN_HEADER]: evaluatingOidcToken } : null,
+    ...isDebugMode ? { "x-vercel-debug-ingest": "1" } : null
+  };
+}
+async function sendIngestEvents(options, events, flushId) {
+  const eventsToSend = events.map((event) => event.ingestEvent());
+  for (let attempt = 1; attempt <= MAX_RETRIES; attempt++) {
+    try {
+      const response = await options.fetch(`${options.host}/v1/ingest`, {
+        method: "POST",
+        headers: await getIngestHeaders(options),
+        body: JSON.stringify(eventsToSend)
+      });
+      debugLog(
+        `@vercel/flags-core: Ingest response ${response.status} for ${eventsToSend.length} events on ${response.headers.get("x-vercel-id")}`
+      );
+      if (response.ok) {
+        break;
+      }
+      throw new Error(
+        `Ingest endpoint responded with status ${response.status} for ${eventsToSend.length} events on request ${response.headers.get("x-vercel-id")}.
+Response body: ${await response.text().catch(() => null)}`
+      );
+    } catch (error) {
+      console.error(
+        `@vercel/flags-core: Error sending events (attempt=${attempt}/${MAX_RETRIES} flushId=${flushId}):`,
+        error
+      );
+      if (attempt < MAX_RETRIES) {
+        const delayMs = getRetryDelayMs(attempt);
+        await new Promise((res) => setTimeout(res, delayMs));
+      } else {
+        console.error(
+          `@vercel/flags-core: Dropped ${eventsToSend.length} events after ${MAX_RETRIES} attempts (flushId=${flushId})`
+        );
+      }
+    }
+  }
+}
+
+// src/utils/request-context.ts
 var SYMBOL_FOR_REQ_CONTEXT = /* @__PURE__ */ Symbol.for("@vercel/request-context");
 var fromSymbol = globalThis;
 function getRequestContext() {
@@ -838,36 +953,227 @@ function getRequestContext() {
         headers: ctx.headers
       };
     }
-    return { ctx, headers: void 0 };
+    return { ctx: void 0, headers: void 0 };
   } catch {
     return { ctx: void 0, headers: void 0 };
   }
 }
+
+// src/utils/scheduler.ts
+import { waitUntil } from "@vercel/functions";
+var MAX_COUNT = 50;
+var IDLE_FLUSH_WAIT_MS = 5e3;
+var MAX_FLUSH_WAIT_MS = 6e4;
+var Scheduler = class {
+  constructor(onFlush) {
+    this.onFlush = onFlush;
+  }
+  count = 0;
+  resolveWait = null;
+  pending = null;
+  idleTimeout = null;
+  maxTimeout = null;
+  increment() {
+    this.count += 1;
+    if (this.count >= MAX_COUNT) {
+      this.resolveScheduledFlush();
+    }
+  }
+  scheduleFlush() {
+    if (!this.pending) {
+      this.pending = (async () => {
+        await new Promise((res) => {
+          this.resolveWait = res;
+        });
+        this.reset();
+        await this.onFlush();
+      })();
+      try {
+        waitUntil(this.pending);
+      } catch {
+      }
+      this.maxTimeout = setTimeout(
+        () => this.resolveScheduledFlush(),
+        MAX_FLUSH_WAIT_MS
+      );
+    }
+    this.resetIdleTimeout();
+  }
+  /**
+   * Resolves any in-flight scheduled flush and waits for its ingest to finish.
+   */
+  async shutdown() {
+    this.clearTimeouts();
+    const pending = this.pending;
+    this.resolveWait?.();
+    if (pending) await pending;
+  }
+  resetIdleTimeout() {
+    if (this.idleTimeout) clearTimeout(this.idleTimeout);
+    this.idleTimeout = setTimeout(
+      () => this.resolveScheduledFlush(),
+      IDLE_FLUSH_WAIT_MS
+    );
+  }
+  resolveScheduledFlush() {
+    this.clearTimeouts();
+    this.resolveWait?.();
+  }
+  reset() {
+    this.pending = null;
+    this.resolveWait = null;
+    this.count = 0;
+    this.clearTimeouts();
+  }
+  clearTimeouts() {
+    if (this.idleTimeout) {
+      clearTimeout(this.idleTimeout);
+      this.idleTimeout = null;
+    }
+    if (this.maxTimeout) {
+      clearTimeout(this.maxTimeout);
+      this.maxTimeout = null;
+    }
+  }
+};
+
+// src/utils/usage/flags-config-read.ts
+var FlagsConfigReadEvent = class {
+  payload;
+  constructor(headers, options) {
+    this.payload = {
+      deploymentId: process.env.VERCEL_DEPLOYMENT_ID,
+      region: process.env.VERCEL_REGION
+    };
+    if (headers) {
+      this.payload.vercelRequestId = headers["x-vercel-id"] ?? void 0;
+      this.payload.invocationHost = headers.host ?? void 0;
+    }
+    if (options) {
+      this.payload.configOrigin = options.configOrigin;
+      if (options.cacheStatus !== void 0) {
+        this.payload.cacheStatus = options.cacheStatus;
+      }
+      if (options.cacheAction !== void 0) {
+        this.payload.cacheAction = options.cacheAction;
+      }
+      if (options.cacheIsFirstRead !== void 0) {
+        this.payload.cacheIsFirstRead = options.cacheIsFirstRead;
+      }
+      if (options.cacheIsBlocking !== void 0) {
+        this.payload.cacheIsBlocking = options.cacheIsBlocking;
+      }
+      if (options.duration !== void 0) {
+        this.payload.duration = options.duration;
+      }
+      if (options.configUpdatedAt !== void 0) {
+        this.payload.configUpdatedAt = options.configUpdatedAt;
+      }
+      if (options.mode !== void 0) {
+        this.payload.mode = options.mode;
+      }
+      if (options.revision !== void 0) {
+        this.payload.revision = String(options.revision);
+      }
+    }
+    const environment = process.env.VERCEL_ENV || process.env.NODE_ENV || void 0;
+    if (environment) {
+      this.payload.environment = environment;
+    }
+  }
+  ingestEvent() {
+    return {
+      type: "FLAGS_CONFIG_READ",
+      ts: Date.now(),
+      payload: this.payload
+    };
+  }
+};
+
+// src/utils/usage/flags-evaluation.ts
+function evaluationBatchKey(options) {
+  return JSON.stringify([
+    options.flagKey,
+    options.variant,
+    options.reason,
+    options.clientName ?? null
+  ]);
+}
+var FlagsEvaluationEvent = class {
+  payload;
+  constructor(eventOptions) {
+    this.payload = {
+      flagKey: eventOptions.flagKey,
+      variant: eventOptions.variant,
+      reason: eventOptions.reason,
+      count: 1
+    };
+    if (eventOptions.clientName) {
+      this.payload.clientName = eventOptions.clientName;
+    }
+    Object.defineProperty(this, "batchKey", {
+      value: JSON.stringify([
+        this.payload.flagKey,
+        this.payload.variant,
+        this.payload.reason,
+        this.payload.clientName ?? null
+      ]),
+      enumerable: false
+    });
+  }
+  increment() {
+    this.payload.count += 1;
+  }
+  ingestEvent() {
+    return {
+      type: "FLAGS_EVALUATION",
+      ts: Date.now(),
+      payload: this.payload
+    };
+  }
+};
+
+// src/utils/weak-map.ts
+var BetterWeakMap = class {
+  _values = [];
+  _keys = [];
+  set(key, value) {
+    this._keys.push(key);
+    this._values.push(value);
+  }
+  values() {
+    return this._values;
+  }
+  has(key) {
+    return this._keys.includes(key);
+  }
+  keys() {
+    return this._keys;
+  }
+  clear() {
+    this._values = [];
+    this._keys = [];
+  }
+};
+
+// src/utils/usage-tracker.ts
 var UsageTracker = class {
-  flushCounter = 0;
+  flushCount = 0;
   options;
-  trackedRequests = /* @__PURE__ */ new WeakSet();
-  batcher = {
-    events: [],
-    resolveWait: null,
-    pending: null
-  };
+  scheduler;
+  readEvents = new BetterWeakMap();
+  evaluationEvents = /* @__PURE__ */ new Map();
   constructor(options) {
     this.options = options;
+    this.scheduler = new Scheduler(() => this.flushEvents());
   }
   /**
    * Triggers an immediate flush of any pending events.
    * Returns a promise that resolves when the flush completes.
    */
-  flush() {
-    if (this.batcher.pending) {
-      this.batcher.resolveWait?.();
-      return this.batcher.pending;
-    }
-    if (this.batcher.events.length > 0) {
-      return this.flushEvents();
-    }
-    return RESOLVED_VOID;
+  async shutdown() {
+    await this.scheduler.shutdown();
+    await this.flushEvents();
   }
   /**
    * Tracks a config read event. Deduplicates by request context.
@@ -876,130 +1182,51 @@ var UsageTracker = class {
     try {
       const { ctx, headers } = getRequestContext();
       if (!ctx) return;
-      if (this.trackedRequests.has(ctx)) return;
-      this.trackedRequests.add(ctx);
-      const event = {
-        type: "FLAGS_CONFIG_READ",
-        ts: Date.now(),
-        payload: {
-          deploymentId: process.env.VERCEL_DEPLOYMENT_ID,
-          region: process.env.VERCEL_REGION
-        }
-      };
-      if (headers) {
-        event.payload.vercelRequestId = headers["x-vercel-id"] ?? void 0;
-        event.payload.invocationHost = headers.host ?? void 0;
-      }
-      if (options) {
-        event.payload.configOrigin = options.configOrigin;
-        if (options.cacheStatus !== void 0) {
-          event.payload.cacheStatus = options.cacheStatus;
-        }
-        if (options.cacheAction !== void 0) {
-          event.payload.cacheAction = options.cacheAction;
-        }
-        if (options.cacheIsFirstRead !== void 0) {
-          event.payload.cacheIsFirstRead = options.cacheIsFirstRead;
-        }
-        if (options.cacheIsBlocking !== void 0) {
-          event.payload.cacheIsBlocking = options.cacheIsBlocking;
-        }
-        if (options.duration !== void 0) {
-          event.payload.duration = options.duration;
-        }
-        if (options.configUpdatedAt !== void 0) {
-          event.payload.configUpdatedAt = options.configUpdatedAt;
-        }
-        if (options.mode !== void 0) {
-          event.payload.mode = options.mode;
-        }
-        if (options.revision !== void 0) {
-          event.payload.revision = String(options.revision);
-        }
-      }
-      const environment = process.env.VERCEL_ENV || process.env.NODE_ENV || void 0;
-      if (environment) {
-        event.payload.environment = environment;
+      if (this.readEvents.has(ctx)) {
+        return;
       }
-      this.batcher.events.push(event);
-      this.scheduleFlush();
+      this.readEvents.set(ctx, new FlagsConfigReadEvent(headers, options));
+      this.scheduler.scheduleFlush();
+      this.scheduler.increment();
     } catch (error) {
       console.error("@vercel/flags-core: Failed to record event:", error);
     }
   }
-  scheduleFlush() {
-    if (!this.batcher.pending) {
-      let timeout = null;
-      const pending = (async () => {
-        await new Promise((res) => {
-          this.batcher.resolveWait = res;
-          timeout = setTimeout(
-            res,
-            getJitteredWaitMs(MAX_BATCH_WAIT_MS, BATCH_WAIT_JITTER_RATIO)
-          );
-        });
-        this.batcher.pending = null;
-        this.batcher.resolveWait = null;
-        if (timeout) clearTimeout(timeout);
-        await this.flushEvents();
-      })();
-      try {
-        waitUntil(pending);
-      } catch {
+  /**
+   * Tracks a flag evaluation event.
+   */
+  trackEvaluation(options) {
+    try {
+      const batchKey = evaluationBatchKey(options);
+      const existingEvent = this.evaluationEvents.get(batchKey);
+      if (existingEvent) {
+        existingEvent.increment();
+      } else {
+        this.evaluationEvents.set(batchKey, new FlagsEvaluationEvent(options));
+        this.scheduler.increment();
       }
-      this.batcher.pending = pending;
-    }
-    if (this.batcher.events.length >= MAX_BATCH_SIZE) {
-      this.batcher.resolveWait?.();
+      this.scheduler.scheduleFlush();
+    } catch (error) {
+      console.error(
+        "@vercel/flags-core: Failed to record evaluation event:",
+        error
+      );
     }
   }
+  /**
+   * Send all events to the ingest service
+   */
   async flushEvents() {
-    if (this.batcher.events.length === 0) return;
-    const eventsToSend = this.batcher.events;
-    this.batcher.events = [];
-    const flushId = ++this.flushCounter;
-    for (let attempt = 1; attempt <= MAX_RETRIES; attempt++) {
-      try {
-        const token = await this.options.auth.resolveToken();
-        const response = await this.options.fetch(
-          `${this.options.host}/v1/ingest`,
-          {
-            method: "POST",
-            headers: {
-              "Content-Type": "application/json",
-              Authorization: `Bearer ${token}`,
-              "User-Agent": `VercelFlagsCore/${version}`,
-              ...process.env.VERCEL_ENV ? { "X-Vercel-Env": process.env.VERCEL_ENV } : null,
-              ...isDebugMode ? { "x-vercel-debug-ingest": "1" } : null
-            },
-            body: JSON.stringify(eventsToSend)
-          }
-        );
-        debugLog(
-          `@vercel/flags-core: Ingest response ${response.status} for ${eventsToSend.length} events on ${response.headers.get("x-vercel-id")}`
-        );
-        if (response.ok) {
-          break;
-        }
-        throw new Error(
-          `Ingest endpoint responded with status ${response.status} for ${eventsToSend.length} events on request ${response.headers.get("x-vercel-id")}.
-Response body: ${await response.text().catch(() => null)}`
-        );
-      } catch (error) {
-        console.error(
-          `@vercel/flags-core: Error sending events (attempt=${attempt}/${MAX_RETRIES} flushId=${flushId}):`,
-          error
-        );
-        if (attempt < MAX_RETRIES) {
-          const delayMs = getRetryDelayMs(attempt);
-          await new Promise((res) => setTimeout(res, delayMs));
-        } else {
-          console.error(
-            `@vercel/flags-core: Dropped ${eventsToSend.length} events after ${MAX_RETRIES} attempts (flushId=${flushId})`
-          );
-        }
-      }
-    }
+    const events = [
+      ...this.readEvents.values(),
+      ...this.evaluationEvents.values()
+    ];
+    if (events.length === 0) return;
+    this.flushCount += 1;
+    const flushId = this.flushCount;
+    this.readEvents.clear();
+    this.evaluationEvents.clear();
+    await sendIngestEvents(this.options, events, flushId);
   }
 };
 
@@ -1156,7 +1383,8 @@ function normalizeOptions(options) {
     polling,
     buildStep,
     fetch: options.fetch ?? globalThis.fetch,
-    host: "https://flags.vercel.com"
+    host: "https://flags.vercel.com",
+    clientName: options.clientName
   };
 }
 
@@ -1741,7 +1969,7 @@ var Controller = class {
     this.pollingSource.stop();
     this.data = this.options.datafile ? tagData(this.options.datafile, "provided") : void 0;
     this.transition("shutdown");
-    await this.usageTracker.flush();
+    await this.usageTracker.shutdown();
   }
   /**
    * Returns the datafile with metrics.
@@ -2119,10 +2347,20 @@ var Controller = class {
     }
     this.usageTracker.trackRead(trackOptions);
   }
+  /**
+   * Tracks a flag evaluation for usage analytics.
+   */
+  trackEvaluation(options) {
+    if (this.unauthorized) return;
+    this.usageTracker.trackEvaluation({
+      ...options,
+      clientName: options.clientName ?? this.options.clientName
+    });
+  }
 };
 
 // src/controller/auth.ts
-import { getVercelOidcToken } from "@vercel/oidc";
+import { getVercelOidcToken as getVercelOidcToken2 } from "@vercel/oidc";
 
 // src/utils/sdk-keys.ts
 var SDK_KEY_REGEX = /^vf_(?:server|client)_/;
@@ -2141,7 +2379,7 @@ function parseSdkKeyFromFlagsConnectionString(text) {
 // src/controller/auth.ts
 async function getOidcToken() {
   try {
-    return await getVercelOidcToken();
+    return await getVercelOidcToken2();
   } catch {
     throw new Error(
       [
@@ -2261,4 +2499,4 @@ export {
   resetDefaultFlagsClient,
   createClient
 };
-//# sourceMappingURL=chunk-WTGXBSWR.js.map
+//# sourceMappingURL=chunk-PSYHUXJC.js.map