@vercel/flags-core 1.4.0 → 1.5.0-2225248-20260525123053

package/CHANGELOG.md

@@ -1,5 +1,44 @@
 # @vercel/flags-core
 
+## 1.5.0-2225248-20260525123053
+
+### Minor Changes
+
+- [#385](https://github.com/vercel/flags/pull/385) [`5b2dc37`](https://github.com/vercel/flags/commit/5b2dc37041e24811f735beede41fc8c29f508cb7) Thanks [@dferber90](https://github.com/dferber90)! - Add `bulkEvaluate` method to `FlagsClient` for resolving multiple flags against shared entities in a single call.
+
+  ```ts
+  const results = await client.bulkEvaluate(
+    [
+      { key: "a", defaultValue: false },
+      { key: "b", defaultValue: "off" },
+    ],
+    entities
+  );
+
+  results.a; // EvaluationResult<boolean>
+  results.b; // EvaluationResult<string>
+  ```
+
+  Avoids the per-flag overhead of separate `evaluate()` calls — the datafile is read once, entities are resolved once, and all flags share the same environment/segments lookup. Each entry in the returned record is a full `EvaluationResult` with `value`, `reason`, `outcomeType`, and `metrics`.
+
+- [#371](https://github.com/vercel/flags/pull/371) [`bd4d01a`](https://github.com/vercel/flags/commit/bd4d01a9b2b5d70bf7ae62cda645d8cd7292ad83) Thanks [@vincent-derks](https://github.com/vincent-derks)! - Add jitter to ingest retries and the batch-flush window.
+
+  The usage tracker now uses AWS-style "Full Jitter" exponential backoff between
+  retry attempts (replacing the previous deterministic 100/200ms schedule) and
+  randomizes the 5s batch-flush window by ±20% to desynchronize concurrent
+  processes. When all retry attempts are exhausted the SDK now logs a structured
+  warning so consumers can alert on dropped batches.
+
+### Patch Changes
+
+- [#382](https://github.com/vercel/flags/pull/382) [`4d90e91`](https://github.com/vercel/flags/commit/4d90e912a4d7c9d4ef986d5e8dc609c30b203242) Thanks [@dferber90](https://github.com/dferber90)! - Speed up flag evaluation on the hot path.
+
+  - `handleOutcome` no longer recomputes `scaledWeights` on every split-outcome evaluation; the per-outcome scaled weights are cached on first call.
+  - `matchConditions` no longer recompiles `RegExp` on every REGEX / NOT_REGEX condition; the compiled regex is cached on first call.
+  - `Controller.read()` and `getDatafile()` no longer re-destructure and re-spread the in-memory datafile on every call; the result is cached and rebuilt only when stream/poll replaces the underlying data.
+
+  In micro-benchmarks the pure `evaluate()` path is ~22% faster for split outcomes and ~32% faster for regex conditions. The full `client.evaluate()` path is 14–22% faster across all scenarios.
+
 ## 1.4.0
 
 ### Minor Changes

package/dist/{chunk-WKSYRFUY.cjs → chunk-5TVRNXPQ.cjs}

@@ -7,6 +7,7 @@ var __export = (target, all) => {
 // src/controller-fns.ts
 var controller_fns_exports = {};
 __export(controller_fns_exports, {
+  bulkEvaluate: () => bulkEvaluate2,
   controllerInstanceMap: () => controllerInstanceMap,
   evaluate: () => evaluate2,
   getDatafile: () => getDatafile,
@@ -46,6 +47,24 @@ var Packed;
 
 // src/evaluate.ts
 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");
+function getScaledWeights(outcome) {
+  const cached = outcome[SCALED_WEIGHTS];
+  if (cached) return cached;
+  const total = sum(outcome.weights);
+  const scaled = outcome.weights.map((w) => w / total * UINT32_MAX);
+  outcome[SCALED_WEIGHTS] = scaled;
+  return scaled;
+}
+function getCompiledRegex(rhs) {
+  const cached = rhs[COMPILED_REGEX];
+  if (cached) return cached;
+  const compiled = new RegExp(rhs.pattern, rhs.flags);
+  rhs[COMPILED_REGEX] = compiled;
+  return compiled;
+}
 function exhaustivenessCheck(_) {
   throw new Error("Exhaustiveness check failed");
 }
@@ -232,12 +251,12 @@ function matchConditions(conditions, params) {
           return (isNumber(rhs) || isString(rhs)) && lhs <= rhs;
         case "regex" /* REGEX */:
           if (isString(lhs) && lhs.length <= MAX_REGEX_INPUT_LENGTH && typeof rhs === "object" && !Array.isArray(rhs) && _optionalChain([rhs, 'optionalAccess', _12 => _12.type]) === "regex") {
-            return new RegExp(rhs.pattern, rhs.flags).test(lhs);
+            return getCompiledRegex(rhs).test(lhs);
           }
           return false;
         case "!regex" /* NOT_REGEX */:
           if (isString(lhs) && lhs.length <= MAX_REGEX_INPUT_LENGTH && typeof rhs === "object" && !Array.isArray(rhs) && _optionalChain([rhs, 'optionalAccess', _13 => _13.type]) === "regex") {
-            return !new RegExp(rhs.pattern, rhs.flags).test(lhs);
+            return !getCompiledRegex(rhs).test(lhs);
           }
           return false;
         case "before" /* BEFORE */: {
@@ -309,13 +328,9 @@ function handleOutcome(params, outcome) {
       if (typeof lhs !== "string") {
         return { value: defaultOutcome, outcomeType: "split" /* SPLIT */ };
       }
-      const maxValue = 4294967295;
       const value = _jsxxhash.xxHash32.call(void 0, lhs, params.definition.seed);
-      const sumOfWeights = sum(outcome.weights);
-      const scaledWeights = outcome.weights.map(
-        (weight) => weight / sumOfWeights * maxValue
-      );
-      const variantIndex = findWeightedIndex(scaledWeights, value, maxValue);
+      const scaledWeights = getScaledWeights(outcome);
+      const variantIndex = findWeightedIndex(scaledWeights, value, UINT32_MAX);
       return {
         value: variantIndex === -1 ? defaultOutcome : getVariant(params.definition.variants, variantIndex),
         outcomeType: "split" /* SPLIT */
@@ -371,9 +386,8 @@ function handleOutcome(params, outcome) {
           outcomeType: "rollout" /* ROLLOUT */
         };
       }
-      const maxValue = 4294967295;
       const value = _jsxxhash.xxHash32.call(void 0, lhs, params.definition.seed);
-      const threshold = currentPromille / 1e5 * maxValue;
+      const threshold = currentPromille / 1e5 * UINT32_MAX;
       return {
         value: value < threshold ? getVariant(params.definition.variants, outcome.rollToVariant) : getVariant(
           params.definition.variants,
@@ -440,6 +454,23 @@ function evaluate(params, _visited) {
     reason: "fallthrough" /* FALLTHROUGH */
   });
 }
+function bulkEvaluate(flags, shared) {
+  const params = {
+    entities: shared.entities,
+    environment: shared.environment,
+    segments: shared.segments,
+    definition: void 0,
+    defaultValue: void 0
+  };
+  const results = {};
+  for (const key in flags) {
+    const flag = flags[key];
+    params.definition = flag.definition;
+    params.defaultValue = flag.defaultValue;
+    results[key] = evaluate(params);
+  }
+  return results;
+}
 function findWeightedIndex(weights, value, maxValue) {
   if (value < 0 || value >= maxValue) return -1;
   let sum2 = 0;
@@ -451,7 +482,7 @@ function findWeightedIndex(weights, value, maxValue) {
 }
 
 // package.json
-var version = "1.4.0";
+var version = "1.5.0-2225248-20260525123053";
 
 // src/lib/report-value.ts
 function internalReportValue(key, value, data) {
@@ -557,6 +588,78 @@ async function evaluate2(id, flagKey, defaultValue, entities) {
     }
   });
 }
+async function bulkEvaluate2(id, flags, entities) {
+  const controller = getInstance(id).controller;
+  let datafile;
+  try {
+    datafile = await controller.read();
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : "Failed to read datafile";
+    const results2 = {};
+    for (const flag of flags) {
+      results2[flag.key] = {
+        value: flag.defaultValue,
+        reason: "error" /* ERROR */,
+        errorMessage
+      };
+    }
+    return results2;
+  }
+  const baseMetrics = {
+    readMs: datafile.metrics.readMs,
+    source: datafile.metrics.source,
+    cacheStatus: datafile.metrics.cacheStatus,
+    connectionState: datafile.metrics.connectionState,
+    mode: datafile.metrics.mode
+  };
+  const projectId = datafile.projectId;
+  const results = {};
+  const toEvaluate = {};
+  for (const flag of flags) {
+    const { key, defaultValue } = flag;
+    const flagDefinition = datafile.definitions[key];
+    if (flagDefinition === void 0) {
+      if (projectId) {
+        internalReportValue(key, defaultValue, {
+          originProjectId: projectId,
+          originProvider: "vercel",
+          reason: "error" /* ERROR */
+        });
+      }
+      results[key] = {
+        value: defaultValue,
+        reason: "error" /* ERROR */,
+        errorCode: "FLAG_NOT_FOUND" /* FLAG_NOT_FOUND */,
+        errorMessage: `@vercel/flags-core: Definition not found for flag "${key}"`,
+        metrics: { evaluationMs: 0, ...baseMetrics }
+      };
+      continue;
+    }
+    toEvaluate[key] = { definition: flagDefinition, defaultValue };
+  }
+  const evalStartTime = Date.now();
+  const evaluated = bulkEvaluate(toEvaluate, {
+    entities: _nullishCoalesce(entities, () => ( {})),
+    environment: datafile.environment,
+    segments: datafile.segments
+  });
+  const evaluationDurationMs = Date.now() - evalStartTime;
+  for (const key in toEvaluate) {
+    const result = evaluated[key];
+    if (projectId) {
+      internalReportValue(key, result.value, {
+        originProjectId: projectId,
+        originProvider: "vercel",
+        reason: result.reason,
+        outcomeType: result.reason !== "error" /* ERROR */ ? result.outcomeType : void 0
+      });
+    }
+    results[key] = Object.assign(result, {
+      metrics: { evaluationMs: evaluationDurationMs, ...baseMetrics }
+    });
+  }
+  return results;
+}
 
 // src/create-raw-client.ts
 var idCount = 0;
@@ -623,6 +726,16 @@ function createCreateRawClient(fns) {
           }
         }
         return fns.evaluate(id, flagKey, defaultValue, entities);
+      },
+      bulkEvaluate: async (flags, entities) => {
+        const instance = controllerInstanceMap.get(id);
+        if (!_optionalChain([instance, 'optionalAccess', _22 => _22.initialized])) {
+          try {
+            await api.initialize();
+          } catch (e3) {
+          }
+        }
+        return fns.bulkEvaluate(id, flags, entities);
       }
     };
     return api;
@@ -677,8 +790,25 @@ async function readBundledDefinitions(sdkKey) {
 
 // src/utils/usage-tracker.ts
 var _functions = require('@vercel/functions');
+
+// src/utils/backoff.ts
+var DEFAULT_BASE_MS = 250;
+var DEFAULT_CAP_MS = 5e3;
+function getRetryDelayMs(attempt, options = {}) {
+  const baseMs = _nullishCoalesce(options.baseMs, () => ( DEFAULT_BASE_MS));
+  const capMs = _nullishCoalesce(options.capMs, () => ( DEFAULT_CAP_MS));
+  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', _22 => _22.env, 'access', _23 => _23.DEBUG, 'optionalAccess', _24 => _24.includes, 'call', _25 => _25("@vercel/flags-core")]);
+var isDebugMode = _optionalChain([process, 'access', _23 => _23.env, 'access', _24 => _24.DEBUG, 'optionalAccess', _25 => _25.includes, 'call', _26 => _26("@vercel/flags-core")]);
 var debugLog = (...args) => {
   if (!isDebugMode) return;
   console.log(...args);
@@ -686,11 +816,12 @@ var debugLog = (...args) => {
 var MAX_RETRIES = 3;
 var MAX_BATCH_SIZE = 50;
 var MAX_BATCH_WAIT_MS = 5e3;
+var BATCH_WAIT_JITTER_RATIO = 0.2;
 var SYMBOL_FOR_REQ_CONTEXT = /* @__PURE__ */ Symbol.for("@vercel/request-context");
 var fromSymbol = globalThis;
 function getRequestContext() {
   try {
-    const ctx = _optionalChain([fromSymbol, 'access', _26 => _26[SYMBOL_FOR_REQ_CONTEXT], 'optionalAccess', _27 => _27.get, 'optionalCall', _28 => _28()]);
+    const ctx = _optionalChain([fromSymbol, 'access', _27 => _27[SYMBOL_FOR_REQ_CONTEXT], 'optionalAccess', _28 => _28.get, 'optionalCall', _29 => _29()]);
     if (ctx && Object.hasOwn(ctx, "headers")) {
       return {
         ctx,
@@ -698,7 +829,7 @@ function getRequestContext() {
       };
     }
     return { ctx, headers: void 0 };
-  } catch (e3) {
+  } catch (e4) {
     return { ctx: void 0, headers: void 0 };
   }
 }
@@ -720,7 +851,7 @@ var UsageTracker = (_class = class {
    */
   flush() {
     if (this.batcher.pending) {
-      _optionalChain([this, 'access', _29 => _29.batcher, 'access', _30 => _30.resolveWait, 'optionalCall', _31 => _31()]);
+      _optionalChain([this, 'access', _30 => _30.batcher, 'access', _31 => _31.resolveWait, 'optionalCall', _32 => _32()]);
       return this.batcher.pending;
     }
     if (this.batcher.events.length > 0) {
@@ -792,7 +923,10 @@ var UsageTracker = (_class = class {
       const pending = (async () => {
         await new Promise((res) => {
           this.batcher.resolveWait = res;
-          timeout = setTimeout(res, MAX_BATCH_WAIT_MS);
+          timeout = setTimeout(
+            res,
+            getJitteredWaitMs(MAX_BATCH_WAIT_MS, BATCH_WAIT_JITTER_RATIO)
+          );
         });
         this.batcher.pending = null;
         this.batcher.resolveWait = null;
@@ -801,12 +935,12 @@ var UsageTracker = (_class = class {
       })();
       try {
         _functions.waitUntil.call(void 0, pending);
-      } catch (e4) {
+      } catch (e5) {
       }
       this.batcher.pending = pending;
     }
     if (this.batcher.events.length >= MAX_BATCH_SIZE) {
-      _optionalChain([this, 'access', _32 => _32.batcher, 'access', _33 => _33.resolveWait, 'optionalCall', _34 => _34()]);
+      _optionalChain([this, 'access', _33 => _33.batcher, 'access', _34 => _34.resolveWait, 'optionalCall', _35 => _35()]);
     }
   }
   async flushEvents() {
@@ -846,7 +980,12 @@ Response body: ${await response.text().catch(() => null)}`
           error
         );
         if (attempt < MAX_RETRIES) {
-          await new Promise((res) => setTimeout(res, attempt * 100));
+          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})`
+          );
         }
       }
     }
@@ -911,7 +1050,7 @@ var BundledSource = class {
    */
   async tryLoad() {
     const result = await this.getResult();
-    if (_optionalChain([result, 'optionalAccess', _35 => _35.state]) === "ok" && result.definitions) {
+    if (_optionalChain([result, 'optionalAccess', _36 => _36.state]) === "ok" && result.definitions) {
       return result.definitions;
     }
     return void 0;
@@ -950,14 +1089,14 @@ async function fetchDatafile(options) {
       signal: controller.signal
     });
     clearTimeout(timeoutId);
-    _optionalChain([options, 'access', _36 => _36.signal, 'optionalAccess', _37 => _37.removeEventListener, 'call', _38 => _38("abort", onExternalAbort)]);
+    _optionalChain([options, 'access', _37 => _37.signal, 'optionalAccess', _38 => _38.removeEventListener, 'call', _39 => _39("abort", onExternalAbort)]);
     if (!res.ok) {
       throw new Error(`Failed to fetch data: ${res.statusText}`);
     }
     return res.json();
   } catch (error) {
     clearTimeout(timeoutId);
-    _optionalChain([options, 'access', _39 => _39.signal, 'optionalAccess', _40 => _40.removeEventListener, 'call', _41 => _41("abort", onExternalAbort)]);
+    _optionalChain([options, 'access', _40 => _40.signal, 'optionalAccess', _41 => _41.removeEventListener, 'call', _42 => _42("abort", onExternalAbort)]);
     throw error instanceof Error ? error : new Error("Unknown fetch error");
   }
 }
@@ -1022,7 +1161,7 @@ var TypedEmitter = (_class2 = class {constructor() { _class2.prototype.__init4.c
     set.add(handler);
   }
   off(event, handler) {
-    _optionalChain([this, 'access', _42 => _42.handlers, 'access', _43 => _43.get, 'call', _44 => _44(event), 'optionalAccess', _45 => _45.delete, 'call', _46 => _46(handler)]);
+    _optionalChain([this, 'access', _43 => _43.handlers, 'access', _44 => _44.get, 'call', _45 => _45(event), 'optionalAccess', _46 => _46.delete, 'call', _47 => _47(handler)]);
   }
   emit(event, ...args) {
     const set = this.handlers.get(event);
@@ -1048,11 +1187,11 @@ var PollingSource = class extends TypedEmitter {
    * Emits 'data' on success, 'error' on failure.
    */
   async poll() {
-    if (_optionalChain([this, 'access', _47 => _47.abortController, 'optionalAccess', _48 => _48.signal, 'access', _49 => _49.aborted])) return;
+    if (_optionalChain([this, 'access', _48 => _48.abortController, 'optionalAccess', _49 => _49.signal, 'access', _50 => _50.aborted])) return;
     try {
       const data = await fetchDatafile({
         ...this.config,
-        signal: _optionalChain([this, 'access', _50 => _50.abortController, 'optionalAccess', _51 => _51.signal])
+        signal: _optionalChain([this, 'access', _51 => _51.abortController, 'optionalAccess', _52 => _52.signal])
       });
       this.emit("data", data);
     } catch (error) {
@@ -1081,7 +1220,7 @@ var PollingSource = class extends TypedEmitter {
       clearInterval(this.intervalId);
       this.intervalId = void 0;
     }
-    _optionalChain([this, 'access', _52 => _52.abortController, 'optionalAccess', _53 => _53.abort, 'call', _54 => _54()]);
+    _optionalChain([this, 'access', _53 => _53.abortController, 'optionalAccess', _54 => _54.abort, 'call', _55 => _55()]);
     this.abortController = void 0;
   }
 };
@@ -1150,7 +1289,7 @@ async function connectStream(config, callbacks) {
         if (pingTimeoutId !== void 0) clearTimeout(pingTimeoutId);
         if (!initialDataReceived) return;
         pingTimeoutId = setTimeout(() => {
-          _optionalChain([responseBody, 'optionalAccess', _55 => _55.cancel, 'call', _56 => _56(), 'access', _57 => _57.catch, 'call', _58 => _58(() => {
+          _optionalChain([responseBody, 'optionalAccess', _56 => _56.cancel, 'call', _57 => _57(), 'access', _58 => _58.catch, 'call', _59 => _59(() => {
           })]);
           connectionAbort.abort();
         }, PING_TIMEOUT_MS);
@@ -1166,7 +1305,7 @@ async function connectStream(config, callbacks) {
         if (vercelEnv) {
           headers["X-Vercel-Env"] = vercelEnv;
         }
-        const revision = _optionalChain([config, 'access', _59 => _59.revision, 'optionalCall', _60 => _60()]);
+        const revision = _optionalChain([config, 'access', _60 => _60.revision, 'optionalCall', _61 => _61()]);
         if (revision !== void 0) {
           headers["X-Revision"] = String(revision);
         }
@@ -1212,7 +1351,7 @@ async function connectStream(config, callbacks) {
               let message;
               try {
                 message = JSON.parse(line);
-              } catch (e5) {
+              } catch (e6) {
                 console.warn(
                   "@vercel/flags-core: Failed to parse stream message, skipping"
                 );
@@ -1228,7 +1367,7 @@ async function connectStream(config, callbacks) {
                 resetPingTimeout();
               }
               if (message.type === "primed") {
-                _optionalChain([onPrimed, 'optionalCall', _61 => _61(message)]);
+                _optionalChain([onPrimed, 'optionalCall', _62 => _62(message)]);
                 retryCount = 0;
                 if (!initialDataReceived) {
                   initialDataReceived = true;
@@ -1251,7 +1390,7 @@ async function connectStream(config, callbacks) {
         clearTimeout(pingTimeoutId);
         abortController.signal.removeEventListener("abort", onMainAbort);
         if (!abortController.signal.aborted) {
-          _optionalChain([onDisconnect, 'optionalCall', _62 => _62()]);
+          _optionalChain([onDisconnect, 'optionalCall', _63 => _63()]);
           retryCount++;
           const elapsed = Date.now() - lastAttemptTime;
           const minGap = Math.max(0, BASE_RETRY_DELAY_MS - elapsed);
@@ -1267,7 +1406,7 @@ async function connectStream(config, callbacks) {
         if (!connectionAbort.signal.aborted) {
           console.error("@vercel/flags-core: Stream error", error);
         }
-        _optionalChain([onDisconnect, 'optionalCall', _63 => _63()]);
+        _optionalChain([onDisconnect, 'optionalCall', _64 => _64()]);
         retryCount++;
         const elapsed = Date.now() - lastAttemptTime;
         const minGap = Math.max(0, BASE_RETRY_DELAY_MS - elapsed);
@@ -1346,7 +1485,7 @@ var StreamSource = class extends TypedEmitter {
    * Stop the stream connection.
    */
   stop() {
-    _optionalChain([this, 'access', _64 => _64.abortController, 'optionalAccess', _65 => _65.abort, 'call', _66 => _66()]);
+    _optionalChain([this, 'access', _65 => _65.abortController, 'optionalAccess', _66 => _66.abort, 'call', _67 => _67()]);
     this.abortController = void 0;
     this.promise = void 0;
   }
@@ -1384,19 +1523,24 @@ var Controller = (_class3 = class {
   __init5() {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}
   // Sources (I/O delegates)
   
   
   
   // Usage tracking
   
-  __init6() {this.isFirstGetData = true}
+  __init8() {this.isFirstGetData = true}
   // Build-step deduplication
-  __init7() {this.buildDataPromise = null}
-  __init8() {this.buildReadTracked = false}
+  __init9() {this.buildDataPromise = null}
+  __init10() {this.buildReadTracked = false}
   // Suppresses usage tracking when the SDK key is unauthorized
-  __init9() {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);
+  __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);
     if (!options.sdkKey || typeof options.sdkKey !== "string" || !options.sdkKey.startsWith("vf_")) {
       throw new Error(
         '@vercel/flags-core: SDK key must be a string starting with "vf_"'
@@ -1405,7 +1549,7 @@ var Controller = (_class3 = class {
     this.options = normalizeOptions(options);
     this.streamSource = new StreamSource(
       this.options,
-      () => _optionalChain([this, 'access', _67 => _67.data, 'optionalAccess', _68 => _68.revision])
+      () => _optionalChain([this, 'access', _68 => _68.data, 'optionalAccess', _69 => _69.revision])
     );
     this.pollingSource = new PollingSource(this.options);
     this.bundledSource = new BundledSource({
@@ -1419,32 +1563,32 @@ var Controller = (_class3 = class {
     this.usageTracker = new UsageTracker(this.options);
   }
   // Source event handlers (stored for cleanup)
-  __init10() {this.onStreamData = (data) => {
+  __init12() {this.onStreamData = (data) => {
     if (this.isNewerData(data)) {
       this.data = tagData(data, "stream");
     }
   }}
-  __init11() {this.onStreamPrimed = () => {
+  __init13() {this.onStreamPrimed = () => {
     if (this.state === "degraded" || this.state === "initializing:stream") {
       this.transition("streaming");
     }
   }}
-  __init12() {this.onStreamConnected = () => {
+  __init14() {this.onStreamConnected = () => {
     if (this.state === "degraded" || this.state === "initializing:stream") {
       this.transition("streaming");
     }
   }}
-  __init13() {this.onStreamDisconnected = () => {
+  __init15() {this.onStreamDisconnected = () => {
     if (this.state === "streaming") {
       this.transition("degraded");
     }
   }}
-  __init14() {this.onPollData = (data) => {
+  __init16() {this.onPollData = (data) => {
     if (this.isNewerData(data)) {
       this.data = tagData(data, "poll");
     }
   }}
-  __init15() {this.onPollError = (error) => {
+  __init17() {this.onPollError = (error) => {
     console.error("@vercel/flags-core: Poll failed:", error);
   }}
   // ---------------------------------------------------------------------------
@@ -1513,7 +1657,7 @@ var Controller = (_class3 = class {
         if (bundled) {
           this.data = tagData(bundled, "bundled");
         }
-      } catch (e6) {
+      } catch (e7) {
       }
     }
     if (this.data) {
@@ -1555,11 +1699,15 @@ var Controller = (_class3 = class {
     this.isFirstGetData = false;
     const [result, cacheStatus] = await this.resolveData();
     const readMs = Date.now() - startTime;
-    const { _origin, ...data } = result;
-    const source = originToMetricsSource(_origin);
+    const source = originToMetricsSource(result._origin);
     this.trackRead(startTime, cacheHadDefinitions, isFirstRead, source);
+    if (this.dataViewSource !== result) {
+      const { _origin, ...rest } = result;
+      this.dataViewBase = rest;
+      this.dataViewSource = result;
+    }
     return {
-      ...data,
+      ...this.dataViewBase,
       metrics: {
         readMs,
         source,
@@ -1611,7 +1759,7 @@ var Controller = (_class3 = class {
           this.data = tagData(fetched, "fetched");
           result = this.data;
           cacheStatus = "MISS";
-        } catch (e7) {
+        } catch (e8) {
           throw new Error(
             "@vercel/flags-core: No flag definitions available. Initialize the client or provide a datafile."
           );
@@ -1619,8 +1767,13 @@ var Controller = (_class3 = class {
       }
     }
     const source = originToMetricsSource(result._origin);
+    if (this.dataViewSource !== result) {
+      const { _origin, ...rest } = result;
+      this.dataViewBase = rest;
+      this.dataViewSource = result;
+    }
     return {
-      ...result,
+      ...this.dataViewBase,
       metrics: {
         readMs: Date.now() - startTime,
         source,
@@ -1725,7 +1878,7 @@ var Controller = (_class3 = class {
           return true;
         }
         return false;
-      } catch (e8) {
+      } catch (e9) {
         return false;
       }
     }
@@ -1750,7 +1903,7 @@ var Controller = (_class3 = class {
         return true;
       }
       return false;
-    } catch (e9) {
+    } catch (e10) {
       clearTimeout(timeoutId);
       return false;
     }
@@ -1800,7 +1953,7 @@ var Controller = (_class3 = class {
         fetch: this.options.fetch
       });
       return tagData(fetched, "fetched");
-    } catch (e10) {
+    } catch (e11) {
     }
     throw new Error(
       "@vercel/flags-core: No flag definitions available during build. Provide a datafile or bundled definitions."
@@ -1834,7 +1987,7 @@ var Controller = (_class3 = class {
         this.data = tagData(fetched, "fetched");
         this.transition("degraded");
         return;
-      } catch (e11) {
+      } catch (e12) {
       }
     }
     throw new Error(
@@ -1886,7 +2039,7 @@ var Controller = (_class3 = class {
         this.data = tagData(fetched, "fetched");
         this.transition("degraded");
         return [this.data, "MISS"];
-      } catch (e12) {
+      } catch (e13) {
       }
     }
     throw new Error(
@@ -1938,11 +2091,11 @@ var Controller = (_class3 = class {
       duration: Date.now() - startTime,
       mode: mode === "streaming" ? "stream" : mode === "polling" ? "poll" : mode
     };
-    const configUpdatedAt = _optionalChain([this, 'access', _69 => _69.data, 'optionalAccess', _70 => _70.configUpdatedAt]);
+    const configUpdatedAt = _optionalChain([this, 'access', _70 => _70.data, 'optionalAccess', _71 => _71.configUpdatedAt]);
     if (typeof configUpdatedAt === "number") {
       trackOptions.configUpdatedAt = configUpdatedAt;
     }
-    const revision = _optionalChain([this, 'access', _71 => _71.data, 'optionalAccess', _72 => _72.revision]);
+    const revision = _optionalChain([this, 'access', _72 => _72.data, 'optionalAccess', _73 => _73.revision]);
     if (typeof revision === "number") {
       trackOptions.revision = revision;
     }
@@ -1962,7 +2115,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 (e13) {
+  } catch (e14) {
   }
   return null;
 }
@@ -2045,4 +2198,4 @@ var {
 
 
 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-WKSYRFUY.cjs.map
+//# sourceMappingURL=chunk-5TVRNXPQ.cjs.map