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

package/dist/{chunk-CSSU7O2G.cjs → chunk-LPIUDLYE.cjs}

@@ -1,4 +1,4 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { newObj[key] = obj[key]; } } } newObj.default = obj; return newObj; } } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } var _class; var _class2; var _class3;// src/index.next-js.ts
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { newObj[key] = obj[key]; } } } newObj.default = obj; return newObj; } } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } var _class; var _class2; var _class3; var _class4; var _class5;// src/index.next-js.ts
 var _cache = require('next/cache');
 
 // src/evaluate.ts
@@ -35,6 +35,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;
@@ -298,10 +314,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": {
@@ -311,15 +328,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 = _jsxxhash.xxHash32.call(void 0, 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);
@@ -328,18 +351,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;
@@ -354,32 +379,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 = _jsxxhash.xxHash32.call(void 0, 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;
@@ -467,7 +487,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) {
@@ -506,6 +526,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 _nullishCoalesce(_optionalChain([definition, 'access', _20 => _20.variantIds, 'optionalAccess', _21 => _21[variantIndex]]), () => ( String(variantIndex)));
+}
+function trackEvaluation(controller, options) {
+  _optionalChain([controller, 'access', _22 => _22.trackEvaluation, 'optionalCall', _23 => _23(options)]);
+}
 async function evaluate2(id, flagKey, defaultValue, entities) {
   const controller = getInstance(id).controller;
   let datafile;
@@ -513,11 +541,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;
   }
@@ -530,7 +564,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 */,
@@ -544,6 +578,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({
@@ -562,6 +602,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,
@@ -587,6 +635,11 @@ async function bulkEvaluate2(id, flags, entities) {
         reason: "error" /* ERROR */,
         errorMessage
       };
+      trackEvaluation(controller, {
+        flagKey: flag.key,
+        variant: "unknown",
+        reason: "error" /* ERROR */
+      });
     }
     return results2;
   }
@@ -618,6 +671,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 };
@@ -639,6 +697,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 }
     });
@@ -691,7 +757,7 @@ function createCreateRawClient(fns) {
       },
       getDatafile: async () => {
         const instance = controllerInstanceMap.get(id);
-        if (_optionalChain([instance, 'optionalAccess', _20 => _20.initPromise])) {
+        if (_optionalChain([instance, 'optionalAccess', _24 => _24.initPromise])) {
           try {
             await instance.initPromise;
           } catch (e) {
@@ -704,7 +770,7 @@ function createCreateRawClient(fns) {
       },
       evaluate: async (flagKey, defaultValue, entities) => {
         const instance = controllerInstanceMap.get(id);
-        if (!_optionalChain([instance, 'optionalAccess', _21 => _21.initialized])) {
+        if (!_optionalChain([instance, 'optionalAccess', _25 => _25.initialized])) {
           try {
             await api.initialize();
           } catch (e2) {
@@ -714,7 +780,7 @@ function createCreateRawClient(fns) {
       },
       bulkEvaluate: async (flags, entities) => {
         const instance = controllerInstanceMap.get(id);
-        if (!_optionalChain([instance, 'optionalAccess', _22 => _22.initialized])) {
+        if (!_optionalChain([instance, 'optionalAccess', _26 => _26.initialized])) {
           try {
             await api.initialize();
           } catch (e3) {
@@ -783,8 +849,8 @@ async function readBundledDefinitions(auth) {
   return { definitions: null, state: "missing-entry" };
 }
 
-// src/utils/usage-tracker.ts
-var _functions = require('@vercel/functions');
+// src/utils/ingest.ts
+var _oidc = require('@vercel/oidc');
 
 // src/utils/backoff.ts
 var DEFAULT_BASE_MS = 250;
@@ -795,64 +861,304 @@ 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();
-var isDebugMode = _optionalChain([process, 'access', _23 => _23.env, 'access', _24 => _24.DEBUG, 'optionalAccess', _25 => _25.includes, 'call', _26 => _26("@vercel/flags-core")]);
+// src/utils/ingest.ts
+var MAX_RETRIES = 3;
+var EVALUATING_OIDC_TOKEN_HEADER = "X-Vercel-Flags-Evaluating-OIDC-Token";
+var isDebugMode = _optionalChain([process, 'access', _27 => _27.env, 'access', _28 => _28.DEBUG, 'optionalAccess', _29 => _29.includes, 'call', _30 => _30("@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 _oidc.getVercelOidcToken.call(void 0, );
+  } catch (e4) {
+    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() {
   try {
-    const ctx = _optionalChain([fromSymbol, 'access', _27 => _27[SYMBOL_FOR_REQ_CONTEXT], 'optionalAccess', _28 => _28.get, 'optionalCall', _29 => _29()]);
+    const ctx = _optionalChain([fromSymbol, 'access', _31 => _31[SYMBOL_FOR_REQ_CONTEXT], 'optionalAccess', _32 => _32.get, 'optionalCall', _33 => _33()]);
     if (ctx && Object.hasOwn(ctx, "headers")) {
       return {
         ctx,
         headers: ctx.headers
       };
     }
-    return { ctx, headers: void 0 };
-  } catch (e4) {
+    return { ctx: void 0, headers: void 0 };
+  } catch (e5) {
     return { ctx: void 0, headers: void 0 };
   }
 }
-var UsageTracker = (_class = class {
-  __init() {this.flushCounter = 0}
+
+// src/utils/scheduler.ts
+var _functions = require('@vercel/functions');
+var MAX_COUNT = 50;
+var IDLE_FLUSH_WAIT_MS = 5e3;
+var MAX_FLUSH_WAIT_MS = 6e4;
+var Scheduler = (_class = class {
+  constructor(onFlush) {;_class.prototype.__init.call(this);_class.prototype.__init2.call(this);_class.prototype.__init3.call(this);_class.prototype.__init4.call(this);_class.prototype.__init5.call(this);
+    this.onFlush = onFlush;
+  }
+  __init() {this.count = 0}
+  __init2() {this.resolveWait = null}
+  __init3() {this.pending = null}
+  __init4() {this.idleTimeout = null}
+  __init5() {this.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 {
+        _functions.waitUntil.call(void 0, this.pending);
+      } catch (e6) {
+      }
+      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;
+    _optionalChain([this, 'access', _34 => _34.resolveWait, 'optionalCall', _35 => _35()]);
+    if (pending) await pending;
+  }
+  resetIdleTimeout() {
+    if (this.idleTimeout) clearTimeout(this.idleTimeout);
+    this.idleTimeout = setTimeout(
+      () => this.resolveScheduledFlush(),
+      IDLE_FLUSH_WAIT_MS
+    );
+  }
+  resolveScheduledFlush() {
+    this.clearTimeouts();
+    _optionalChain([this, 'access', _36 => _36.resolveWait, 'optionalCall', _37 => _37()]);
+  }
+  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;
+    }
+  }
+}, _class);
+
+// src/utils/usage/flags-config-read.ts
+var FlagsConfigReadEvent = class {
   
-  __init2() {this.trackedRequests = /* @__PURE__ */ new WeakSet()}
-  __init3() {this.batcher = {
-    events: [],
-    resolveWait: null,
-    pending: null
-  }}
-  constructor(options) {;_class.prototype.__init.call(this);_class.prototype.__init2.call(this);_class.prototype.__init3.call(this);
+  constructor(headers, options) {
+    this.payload = {
+      deploymentId: process.env.VERCEL_DEPLOYMENT_ID,
+      region: process.env.VERCEL_REGION
+    };
+    if (headers) {
+      this.payload.vercelRequestId = _nullishCoalesce(headers["x-vercel-id"], () => ( void 0));
+      this.payload.invocationHost = _nullishCoalesce(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,
+    _nullishCoalesce(options.clientName, () => ( null))
+  ]);
+}
+var FlagsEvaluationEvent = class {
+  
+  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,
+        _nullishCoalesce(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 = (_class2 = class {constructor() { _class2.prototype.__init6.call(this);_class2.prototype.__init7.call(this); }
+  __init6() {this._values = []}
+  __init7() {this._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 = [];
+  }
+}, _class2);
+
+// src/utils/usage-tracker.ts
+var UsageTracker = (_class3 = class {
+  __init8() {this.flushCount = 0}
+  
+  
+  __init9() {this.readEvents = new BetterWeakMap()}
+  __init10() {this.evaluationEvents = /* @__PURE__ */ new Map()}
+  constructor(options) {;_class3.prototype.__init8.call(this);_class3.prototype.__init9.call(this);_class3.prototype.__init10.call(this);
     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) {
-      _optionalChain([this, 'access', _30 => _30.batcher, 'access', _31 => _31.resolveWait, 'optionalCall', _32 => _32()]);
-      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.
@@ -861,132 +1167,53 @@ var UsageTracker = (_class = 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 = _nullishCoalesce(headers["x-vercel-id"], () => ( void 0));
-        event.payload.invocationHost = _nullishCoalesce(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 {
-        _functions.waitUntil.call(void 0, pending);
-      } catch (e5) {
+  /**
+   * 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) {
-      _optionalChain([this, 'access', _33 => _33.batcher, 'access', _34 => _34.resolveWait, 'optionalCall', _35 => _35()]);
+      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);
   }
-}, _class);
+}, _class3);
 
 // src/errors.ts
 var FallbackNotFoundError = class extends Error {
@@ -1045,7 +1272,7 @@ var BundledSource = class {
    */
   async tryLoad() {
     const result = await this.getResult();
-    if (_optionalChain([result, 'optionalAccess', _36 => _36.state]) === "ok" && result.definitions) {
+    if (_optionalChain([result, 'optionalAccess', _38 => _38.state]) === "ok" && result.definitions) {
       return result.definitions;
     }
     return void 0;
@@ -1085,14 +1312,14 @@ async function fetchDatafile(options) {
       signal: controller.signal
     });
     clearTimeout(timeoutId);
-    _optionalChain([options, 'access', _37 => _37.signal, 'optionalAccess', _38 => _38.removeEventListener, 'call', _39 => _39("abort", onExternalAbort)]);
+    _optionalChain([options, 'access', _39 => _39.signal, 'optionalAccess', _40 => _40.removeEventListener, 'call', _41 => _41("abort", onExternalAbort)]);
     if (!res.ok) {
       throw new Error(`Failed to fetch data: ${res.statusText}`);
     }
     return res.json();
   } catch (error) {
     clearTimeout(timeoutId);
-    _optionalChain([options, 'access', _40 => _40.signal, 'optionalAccess', _41 => _41.removeEventListener, 'call', _42 => _42("abort", onExternalAbort)]);
+    _optionalChain([options, 'access', _42 => _42.signal, 'optionalAccess', _43 => _43.removeEventListener, 'call', _44 => _44("abort", onExternalAbort)]);
     throw error instanceof Error ? error : new Error("Unknown fetch error");
   }
 }
@@ -1141,13 +1368,14 @@ function normalizeOptions(options) {
     polling,
     buildStep,
     fetch: _nullishCoalesce(options.fetch, () => ( globalThis.fetch)),
-    host: "https://flags.vercel.com"
+    host: "https://flags.vercel.com",
+    clientName: options.clientName
   };
 }
 
 // src/controller/typed-emitter.ts
-var TypedEmitter = (_class2 = class {constructor() { _class2.prototype.__init4.call(this); }
-  __init4() {this.handlers = /* @__PURE__ */ new Map()}
+var TypedEmitter = (_class4 = class {constructor() { _class4.prototype.__init11.call(this); }
+  __init11() {this.handlers = /* @__PURE__ */ new Map()}
   on(event, handler) {
     let set = this.handlers.get(event);
     if (!set) {
@@ -1157,7 +1385,7 @@ var TypedEmitter = (_class2 = class {constructor() { _class2.prototype.__init4.c
     set.add(handler);
   }
   off(event, handler) {
-    _optionalChain([this, 'access', _43 => _43.handlers, 'access', _44 => _44.get, 'call', _45 => _45(event), 'optionalAccess', _46 => _46.delete, 'call', _47 => _47(handler)]);
+    _optionalChain([this, 'access', _45 => _45.handlers, 'access', _46 => _46.get, 'call', _47 => _47(event), 'optionalAccess', _48 => _48.delete, 'call', _49 => _49(handler)]);
   }
   emit(event, ...args) {
     const set = this.handlers.get(event);
@@ -1167,7 +1395,7 @@ var TypedEmitter = (_class2 = class {constructor() { _class2.prototype.__init4.c
       }
     }
   }
-}, _class2);
+}, _class4);
 
 // src/controller/polling-source.ts
 var PollingSource = class extends TypedEmitter {
@@ -1183,11 +1411,11 @@ var PollingSource = class extends TypedEmitter {
    * Emits 'data' on success, 'error' on failure.
    */
   async poll() {
-    if (_optionalChain([this, 'access', _48 => _48.abortController, 'optionalAccess', _49 => _49.signal, 'access', _50 => _50.aborted])) return;
+    if (_optionalChain([this, 'access', _50 => _50.abortController, 'optionalAccess', _51 => _51.signal, 'access', _52 => _52.aborted])) return;
     try {
       const data = await fetchDatafile({
         ...this.config,
-        signal: _optionalChain([this, 'access', _51 => _51.abortController, 'optionalAccess', _52 => _52.signal])
+        signal: _optionalChain([this, 'access', _53 => _53.abortController, 'optionalAccess', _54 => _54.signal])
       });
       this.emit("data", data);
     } catch (error) {
@@ -1216,7 +1444,7 @@ var PollingSource = class extends TypedEmitter {
       clearInterval(this.intervalId);
       this.intervalId = void 0;
     }
-    _optionalChain([this, 'access', _53 => _53.abortController, 'optionalAccess', _54 => _54.abort, 'call', _55 => _55()]);
+    _optionalChain([this, 'access', _55 => _55.abortController, 'optionalAccess', _56 => _56.abort, 'call', _57 => _57()]);
     this.abortController = void 0;
   }
 };
@@ -1286,7 +1514,7 @@ async function connectStream(config, callbacks) {
         if (pingTimeoutId !== void 0) clearTimeout(pingTimeoutId);
         if (!initialDataReceived) return;
         pingTimeoutId = setTimeout(() => {
-          _optionalChain([responseBody, 'optionalAccess', _56 => _56.cancel, 'call', _57 => _57(), 'access', _58 => _58.catch, 'call', _59 => _59(() => {
+          _optionalChain([responseBody, 'optionalAccess', _58 => _58.cancel, 'call', _59 => _59(), 'access', _60 => _60.catch, 'call', _61 => _61(() => {
           })]);
           connectionAbort.abort();
         }, PING_TIMEOUT_MS);
@@ -1305,7 +1533,7 @@ async function connectStream(config, callbacks) {
         if (vercelEnv) {
           headers["X-Vercel-Env"] = vercelEnv;
         }
-        const revision = _optionalChain([config, 'access', _60 => _60.revision, 'optionalCall', _61 => _61()]);
+        const revision = _optionalChain([config, 'access', _62 => _62.revision, 'optionalCall', _63 => _63()]);
         if (revision !== void 0) {
           headers["X-Revision"] = String(revision);
         }
@@ -1351,7 +1579,7 @@ async function connectStream(config, callbacks) {
               let message;
               try {
                 message = JSON.parse(line);
-              } catch (e6) {
+              } catch (e7) {
                 console.warn(
                   "@vercel/flags-core: Failed to parse stream message, skipping"
                 );
@@ -1367,7 +1595,7 @@ async function connectStream(config, callbacks) {
                 resetPingTimeout();
               }
               if (message.type === "primed") {
-                _optionalChain([onPrimed, 'optionalCall', _62 => _62(message)]);
+                _optionalChain([onPrimed, 'optionalCall', _64 => _64(message)]);
                 retryCount = 0;
                 if (!initialDataReceived) {
                   initialDataReceived = true;
@@ -1390,7 +1618,7 @@ async function connectStream(config, callbacks) {
         clearTimeout(pingTimeoutId);
         abortController.signal.removeEventListener("abort", onMainAbort);
         if (!abortController.signal.aborted) {
-          _optionalChain([onDisconnect, 'optionalCall', _63 => _63()]);
+          _optionalChain([onDisconnect, 'optionalCall', _65 => _65()]);
           retryCount++;
           const elapsed = Date.now() - lastAttemptTime;
           const minGap = Math.max(0, BASE_RETRY_DELAY_MS - elapsed);
@@ -1411,7 +1639,7 @@ async function connectStream(config, callbacks) {
         if (!connectionAbort.signal.aborted) {
           console.error("@vercel/flags-core: Stream error", error);
         }
-        _optionalChain([onDisconnect, 'optionalCall', _64 => _64()]);
+        _optionalChain([onDisconnect, 'optionalCall', _66 => _66()]);
         retryCount++;
         const elapsed = Date.now() - lastAttemptTime;
         const minGap = Math.max(0, BASE_RETRY_DELAY_MS - elapsed);
@@ -1490,7 +1718,7 @@ var StreamSource = class extends TypedEmitter {
    * Stop the stream connection.
    */
   stop() {
-    _optionalChain([this, 'access', _65 => _65.abortController, 'optionalAccess', _66 => _66.abort, 'call', _67 => _67()]);
+    _optionalChain([this, 'access', _67 => _67.abortController, 'optionalAccess', _68 => _68.abort, 'call', _69 => _69()]);
     this.abortController = void 0;
     this.promise = void 0;
   }
@@ -1522,34 +1750,34 @@ function parseConfigUpdatedAt(value) {
   }
   return void 0;
 }
-var Controller = (_class3 = class {
+var Controller = (_class5 = class {
   
   // State machine
-  __init5() {this.state = "idle"}
+  __init12() {this.state = "idle"}
   // Data state — tagged with origin
   
   // Memoized data spread for read() / getDatafile().
   // Rebuilt only when `this.data` reference changes (e.g. on stream/poll update).
   // Holds the result of stripping `_origin`; metrics are appended per-call.
-  __init6() {this.dataViewSource = void 0}
-  __init7() {this.dataViewBase = void 0}
+  __init13() {this.dataViewSource = void 0}
+  __init14() {this.dataViewBase = void 0}
   // Sources (I/O delegates)
   
   
   
   // Usage tracking
   
-  __init8() {this.isFirstGetData = true}
+  __init15() {this.isFirstGetData = true}
   // Build-step deduplication
-  __init9() {this.buildDataPromise = null}
-  __init10() {this.buildReadTracked = false}
+  __init16() {this.buildDataPromise = null}
+  __init17() {this.buildReadTracked = false}
   // Suppresses usage tracking when the SDK key is unauthorized
-  __init11() {this.unauthorized = false}
-  constructor(options) {;_class3.prototype.__init5.call(this);_class3.prototype.__init6.call(this);_class3.prototype.__init7.call(this);_class3.prototype.__init8.call(this);_class3.prototype.__init9.call(this);_class3.prototype.__init10.call(this);_class3.prototype.__init11.call(this);_class3.prototype.__init12.call(this);_class3.prototype.__init13.call(this);_class3.prototype.__init14.call(this);_class3.prototype.__init15.call(this);_class3.prototype.__init16.call(this);_class3.prototype.__init17.call(this);
+  __init18() {this.unauthorized = false}
+  constructor(options) {;_class5.prototype.__init12.call(this);_class5.prototype.__init13.call(this);_class5.prototype.__init14.call(this);_class5.prototype.__init15.call(this);_class5.prototype.__init16.call(this);_class5.prototype.__init17.call(this);_class5.prototype.__init18.call(this);_class5.prototype.__init19.call(this);_class5.prototype.__init20.call(this);_class5.prototype.__init21.call(this);_class5.prototype.__init22.call(this);_class5.prototype.__init23.call(this);_class5.prototype.__init24.call(this);
     this.options = normalizeOptions(options);
     this.streamSource = new StreamSource(
       this.options,
-      () => _optionalChain([this, 'access', _68 => _68.data, 'optionalAccess', _69 => _69.revision])
+      () => _optionalChain([this, 'access', _70 => _70.data, 'optionalAccess', _71 => _71.revision])
     );
     this.pollingSource = new PollingSource(this.options);
     this.bundledSource = new BundledSource({
@@ -1563,32 +1791,32 @@ var Controller = (_class3 = class {
     this.usageTracker = new UsageTracker(this.options);
   }
   // Source event handlers (stored for cleanup)
-  __init12() {this.onStreamData = (data) => {
+  __init19() {this.onStreamData = (data) => {
     if (this.isNewerData(data)) {
       this.data = tagData(data, "stream");
     }
   }}
-  __init13() {this.onStreamPrimed = () => {
+  __init20() {this.onStreamPrimed = () => {
     if (this.state === "degraded" || this.state === "initializing:stream") {
       this.transition("streaming");
     }
   }}
-  __init14() {this.onStreamConnected = () => {
+  __init21() {this.onStreamConnected = () => {
     if (this.state === "degraded" || this.state === "initializing:stream") {
       this.transition("streaming");
     }
   }}
-  __init15() {this.onStreamDisconnected = () => {
+  __init22() {this.onStreamDisconnected = () => {
     if (this.state === "streaming") {
       this.transition("degraded");
     }
   }}
-  __init16() {this.onPollData = (data) => {
+  __init23() {this.onPollData = (data) => {
     if (this.isNewerData(data)) {
       this.data = tagData(data, "poll");
     }
   }}
-  __init17() {this.onPollError = (error) => {
+  __init24() {this.onPollError = (error) => {
     console.error("@vercel/flags-core: Poll failed:", error);
   }}
   // ---------------------------------------------------------------------------
@@ -1657,7 +1885,7 @@ var Controller = (_class3 = class {
         if (bundled) {
           this.data = tagData(bundled, "bundled");
         }
-      } catch (e7) {
+      } catch (e8) {
       }
     }
     if (this.data) {
@@ -1726,7 +1954,7 @@ var Controller = (_class3 = 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.
@@ -1759,7 +1987,7 @@ var Controller = (_class3 = class {
           this.data = tagData(fetched, "fetched");
           result = this.data;
           cacheStatus = "MISS";
-        } catch (e8) {
+        } catch (e9) {
           throw new Error(
             "@vercel/flags-core: No flag definitions available. Initialize the client or provide a datafile."
           );
@@ -1878,7 +2106,7 @@ var Controller = (_class3 = class {
           return true;
         }
         return false;
-      } catch (e9) {
+      } catch (e10) {
         return false;
       }
     }
@@ -1903,7 +2131,7 @@ var Controller = (_class3 = class {
         return true;
       }
       return false;
-    } catch (e10) {
+    } catch (e11) {
       clearTimeout(timeoutId);
       return false;
     }
@@ -1953,7 +2181,7 @@ var Controller = (_class3 = class {
         fetch: this.options.fetch
       });
       return tagData(fetched, "fetched");
-    } catch (e11) {
+    } catch (e12) {
     }
     throw new Error(
       "@vercel/flags-core: No flag definitions available during build. Provide a datafile or bundled definitions."
@@ -1987,7 +2215,7 @@ var Controller = (_class3 = class {
         this.data = tagData(fetched, "fetched");
         this.transition("degraded");
         return;
-      } catch (e12) {
+      } catch (e13) {
       }
     }
     throw new Error(
@@ -2039,7 +2267,7 @@ var Controller = (_class3 = class {
         this.data = tagData(fetched, "fetched");
         this.transition("degraded");
         return [this.data, "MISS"];
-      } catch (e13) {
+      } catch (e14) {
       }
     }
     throw new Error(
@@ -2091,11 +2319,11 @@ var Controller = (_class3 = class {
       duration: Date.now() - startTime,
       mode: mode === "streaming" ? "stream" : mode === "polling" ? "poll" : mode
     };
-    const configUpdatedAt = _optionalChain([this, 'access', _70 => _70.data, 'optionalAccess', _71 => _71.configUpdatedAt]);
+    const configUpdatedAt = _optionalChain([this, 'access', _72 => _72.data, 'optionalAccess', _73 => _73.configUpdatedAt]);
     if (typeof configUpdatedAt === "number") {
       trackOptions.configUpdatedAt = configUpdatedAt;
     }
-    const revision = _optionalChain([this, 'access', _72 => _72.data, 'optionalAccess', _73 => _73.revision]);
+    const revision = _optionalChain([this, 'access', _74 => _74.data, 'optionalAccess', _75 => _75.revision]);
     if (typeof revision === "number") {
       trackOptions.revision = revision;
     }
@@ -2104,10 +2332,20 @@ var Controller = (_class3 = class {
     }
     this.usageTracker.trackRead(trackOptions);
   }
-}, _class3);
+  /**
+   * Tracks a flag evaluation for usage analytics.
+   */
+  trackEvaluation(options) {
+    if (this.unauthorized) return;
+    this.usageTracker.trackEvaluation({
+      ...options,
+      clientName: _nullishCoalesce(options.clientName, () => ( this.options.clientName))
+    });
+  }
+}, _class5);
 
 // src/controller/auth.ts
-var _oidc = require('@vercel/oidc');
+
 
 // src/utils/sdk-keys.ts
 var SDK_KEY_REGEX = /^vf_(?:server|client)_/;
@@ -2118,7 +2356,7 @@ function parseSdkKeyFromFlagsConnectionString(text) {
     const params = new URLSearchParams(text.slice(6));
     const sdkKey = params.get("sdkKey");
     if (sdkKey && SDK_KEY_REGEX.test(sdkKey)) return sdkKey;
-  } catch (e14) {
+  } catch (e15) {
   }
   return null;
 }
@@ -2127,7 +2365,7 @@ function parseSdkKeyFromFlagsConnectionString(text) {
 async function getOidcToken() {
   try {
     return await _oidc.getVercelOidcToken.call(void 0, );
-  } catch (e15) {
+  } catch (e16) {
     throw new Error(
       [
         "@vercel/flags-core: Failed to get OIDC token.",
@@ -2222,7 +2460,7 @@ function setCacheLife() {
   try {
     _cache.cacheLife.call(void 0, { revalidate: 0, expire: 0 });
     _cache.cacheLife.call(void 0, { stale: 60 });
-  } catch (e16) {
+  } catch (e17) {
   }
 }
 var cachedFns = {
@@ -2271,4 +2509,4 @@ var { flagsClient, resetDefaultFlagsClient, createClient } = make(
 
 
 exports.ResolutionReason = ResolutionReason; exports.evaluate = evaluate; exports.FallbackNotFoundError = FallbackNotFoundError; exports.FallbackEntryNotFoundError = FallbackEntryNotFoundError; exports.Controller = Controller; exports.flagsClient = flagsClient; exports.resetDefaultFlagsClient = resetDefaultFlagsClient; exports.createClient = createClient;
-//# sourceMappingURL=chunk-CSSU7O2G.cjs.map
+//# sourceMappingURL=chunk-LPIUDLYE.cjs.map