@vercel/flags-core 1.6.0-fa24822-20260629103652 → 1.7.0

package/CHANGELOG.md

@@ -1,10 +1,35 @@
 # @vercel/flags-core
 
-## 1.6.0-fa24822-20260629103652
+## 1.7.0
 
 ### Minor Changes
 
-- [#401](https://github.com/vercel/flags/pull/401) [`1f8b03f`](https://github.com/vercel/flags/commit/1f8b03f2be1624391277322f21d53352017bd6a7) Thanks [@luismeyer](https://github.com/luismeyer)! - Add aggregated flag evaluation telemetry and a `clientName` option for the Vercel Flags client.
+- [#427](https://github.com/vercel/flags/pull/427) [`50b1aa4`](https://github.com/vercel/flags/commit/50b1aa4f9614b8e78f76cc9e3ae539e58a46fa7e) Thanks [@dferber90](https://github.com/dferber90)! - Align rollout, split, and segment split user assignment onto a single hash bucketing scheme.
+
+  Previously splits and rollouts bucketed users with opposite conventions, so switching a flag between a split and a rollout (or locking in a rollout as a split) could reassign users even when the effective distribution was unchanged. All three now derive their cut points from one shared boundary function over the full hash space, so a rollout at a given percentage is identical to the equivalent split.
+
+  Split assignments are effectively unchanged. Rollouts and segment splits are re-bucketed once with this release; after that, converting a flag between outcome types never reassigns anyone.
+
+## 1.6.0
+
+### Minor Changes
+
+- [#401](https://github.com/vercel/flags/pull/401) [`9dff590`](https://github.com/vercel/flags/commit/9dff590bd5628bd93098637c2e9b3d1a043e4d4b) Thanks [@luismeyer](https://github.com/luismeyer)! - Add aggregated flag evaluation telemetry and a `clientName` option for the Vercel Flags client.
+
+## 1.5.2
+
+### Patch Changes
+
+- [#416](https://github.com/vercel/flags/pull/416) [`f60c99d`](https://github.com/vercel/flags/commit/f60c99d70741e5e8e5af0a069deaf34a3129a27e) Thanks [@dferber90](https://github.com/dferber90)! - Fix datafile serialization across the RSC server/client boundary.
+
+  Evaluation memoized scaled split weights and compiled regexes by attaching
+  symbol-keyed properties directly onto objects inside the datafile. While
+  symbols are invisible to `JSON.stringify`, React Server Components serialization
+  walks objects directly and chokes on these (notably the non-serializable
+  `RegExp`), so datafiles could no longer be passed from server to client
+  components. Memoization now uses module-level `WeakMap`s keyed by the
+  outcome/rhs objects, leaving datafile objects pristine while keeping identical
+  caching semantics and lifetime.
 
 ## 1.5.1
 

package/dist/{chunk-ETOLBVKS.js → chunk-3QHXSGEW.js}

@@ -32,22 +32,31 @@ 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];
+var HASH_SPACE = 2 ** 32;
+var PROMILLE_SCALE = 1e5;
+function boundaryFor(numerator, denominator) {
+  return Math.floor(numerator / denominator * HASH_SPACE);
+}
+var splitBoundariesCache = /* @__PURE__ */ new WeakMap();
+var compiledRegexCache = /* @__PURE__ */ new WeakMap();
+function getSplitBoundaries(outcome) {
+  const cached = splitBoundariesCache.get(outcome);
   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;
+  const boundaries = [];
+  let cumulative = 0;
+  for (const weight of outcome.weights) {
+    cumulative += weight;
+    boundaries.push(boundaryFor(cumulative, total));
+  }
+  splitBoundariesCache.set(outcome, boundaries);
+  return boundaries;
 }
 function getCompiledRegex(rhs) {
-  const cached = rhs[COMPILED_REGEX];
+  const cached = compiledRegexCache.get(rhs);
   if (cached) return cached;
   const compiled = new RegExp(rhs.pattern, rhs.flags);
-  rhs[COMPILED_REGEX] = compiled;
+  compiledRegexCache.set(rhs, compiled);
   return compiled;
 }
 function exhaustivenessCheck(_) {
@@ -276,11 +285,10 @@ function handleSegmentOutcome(params, outcome) {
     case "split": {
       const lhs = access(outcome.base, params);
       if (typeof lhs !== "string") return false;
-      const maxValue = 1e5;
       if (outcome.passPromille <= 0) return false;
-      if (outcome.passPromille >= maxValue) return true;
-      const value = hashInput(lhs, params.definition.seed) % maxValue;
-      return value < outcome.passPromille;
+      if (outcome.passPromille >= PROMILLE_SCALE) return true;
+      const bucket = hashInput(lhs, params.definition.seed);
+      return bucket < boundaryFor(outcome.passPromille, PROMILLE_SCALE);
     }
     default: {
       const { type } = outcome;
@@ -325,12 +333,18 @@ function handleOutcome(params, outcome) {
           outcomeType: "split" /* SPLIT */
         };
       }
-      const value = hashInput(lhs, params.definition.seed);
-      const scaledWeights = getScaledWeights(outcome);
-      const variantIndex = findWeightedIndex(scaledWeights, value, UINT32_MAX);
-      const variant = variantIndex === -1 ? defaultOutcome : getVariant(params.definition, variantIndex);
+      const bucket = hashInput(lhs, params.definition.seed);
+      const boundaries = getSplitBoundaries(outcome);
+      for (let index = 0; index < boundaries.length; index++) {
+        if (bucket < boundaries[index]) {
+          return {
+            ...getVariant(params.definition, index),
+            outcomeType: "split" /* SPLIT */
+          };
+        }
+      }
       return {
-        ...variant,
+        ...defaultOutcome,
         outcomeType: "split" /* SPLIT */
       };
     }
@@ -366,7 +380,7 @@ function handleOutcome(params, outcome) {
           break;
         }
       }
-      if (exhausted) currentPromille = 1e5;
+      if (exhausted) currentPromille = PROMILLE_SCALE;
       if (currentPromille <= 0) {
         return {
           ...rollFromVariant,
@@ -377,17 +391,26 @@ function handleOutcome(params, outcome) {
         params.definition,
         outcome.rollToVariant
       );
-      if (currentPromille >= 1e5) {
+      if (currentPromille >= PROMILLE_SCALE) {
         return {
           ...rollToVariant,
           outcomeType: "rollout" /* ROLLOUT */
         };
       }
-      const value = hashInput(lhs, params.definition.seed);
-      const threshold = currentPromille / 1e5 * UINT32_MAX;
-      const variant = value < threshold ? rollToVariant : rollFromVariant;
+      const bucket = hashInput(lhs, params.definition.seed);
+      if (outcome.rollToVariant < outcome.rollFromVariant) {
+        const rollToBoundary = boundaryFor(currentPromille, PROMILLE_SCALE);
+        return {
+          ...bucket < rollToBoundary ? rollToVariant : rollFromVariant,
+          outcomeType: "rollout" /* ROLLOUT */
+        };
+      }
+      const rollFromBoundary = boundaryFor(
+        PROMILLE_SCALE - currentPromille,
+        PROMILLE_SCALE
+      );
       return {
-        ...variant,
+        ...bucket < rollFromBoundary ? rollFromVariant : rollToVariant,
         outcomeType: "rollout" /* ROLLOUT */
       };
     }
@@ -468,18 +491,9 @@ function bulkEvaluate(flags, shared) {
   }
   return results;
 }
-function findWeightedIndex(weights, value, maxValue) {
-  if (value < 0 || value >= maxValue) return -1;
-  let sum2 = 0;
-  for (let i = 0; i < weights.length; i++) {
-    sum2 += weights[i];
-    if (value < sum2) return i;
-  }
-  return -1;
-}
 
 // package.json
-var version = "1.6.0-fa24822-20260629103652";
+var version = "1.7.0";
 
 // src/lib/report-value.ts
 function internalReportValue(key, value, data) {
@@ -854,7 +868,9 @@ function getJitteredWaitMs(baseMs, ratio) {
 
 // src/utils/ingest.ts
 var MAX_RETRIES = 3;
+var MAX_EVENTS_PER_REQUEST = 2e3;
 var EVALUATING_OIDC_TOKEN_HEADER = "X-Vercel-Flags-OIDC-Token";
+var FLUSH_REASON_HEADER = "X-Vercel-Flags-Flush-Reason";
 var isDebugMode = process.env.DEBUG?.includes("@vercel/flags-core");
 var debugLog = (...args) => {
   if (!isDebugMode) return;
@@ -868,25 +884,36 @@ async function getEvaluatingOidcToken(auth) {
     return void 0;
   }
 }
-async function getIngestHeaders(options) {
+async function getIngestHeaders(options, flushReason) {
   const token = await options.auth.resolveToken();
   const evaluatingOidcToken = await getEvaluatingOidcToken(options.auth);
   return {
     "Content-Type": "application/json",
     Authorization: `Bearer ${token}`,
     "User-Agent": `VercelFlagsCore/${version}`,
+    [FLUSH_REASON_HEADER]: flushReason,
     ...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) {
+async function sendIngestEvents(options, events, flushId, flushReason) {
   const eventsToSend = events.map((event) => event.ingestEvent());
+  for (let i = 0; i < eventsToSend.length; i += MAX_EVENTS_PER_REQUEST) {
+    await sendIngestChunk(
+      options,
+      eventsToSend.slice(i, i + MAX_EVENTS_PER_REQUEST),
+      flushId,
+      flushReason
+    );
+  }
+}
+async function sendIngestChunk(options, eventsToSend, flushId, flushReason) {
   for (let attempt = 1; attempt <= MAX_RETRIES; attempt++) {
     try {
       const response = await options.fetch(`${options.host}/v1/ingest`, {
         method: "POST",
-        headers: await getIngestHeaders(options),
+        headers: await getIngestHeaders(options, flushReason),
         body: JSON.stringify(eventsToSend)
       });
       debugLog(
@@ -936,7 +963,6 @@ function getRequestContext() {
 
 // src/utils/scheduler.ts
 import { waitUntil } from "@vercel/functions";
-var MAX_COUNT = 50;
 var IDLE_FLUSH_WAIT_MS = 5e3;
 var IDLE_FLUSH_JITTER_RATIO = 0.2;
 var MAX_FLUSH_WAIT_MS = 6e4;
@@ -944,32 +970,25 @@ 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) => {
+        const reason = await new Promise((res) => {
           this.resolveWait = res;
         });
         this.reset();
-        await this.onFlush();
+        await this.onFlush(reason);
       })();
       try {
         waitUntil(this.pending);
       } catch {
       }
       this.maxTimeout = setTimeout(
-        () => this.resolveScheduledFlush(),
+        () => this.resolveScheduledFlush("max_timeout"),
         MAX_FLUSH_WAIT_MS
       );
     }
@@ -981,24 +1000,23 @@ var Scheduler = class {
   async shutdown() {
     this.clearTimeouts();
     const pending = this.pending;
-    this.resolveWait?.();
+    this.resolveScheduledFlush("shutdown");
     if (pending) await pending;
   }
   resetIdleTimeout() {
     if (this.idleTimeout) clearTimeout(this.idleTimeout);
     this.idleTimeout = setTimeout(
-      () => this.resolveScheduledFlush(),
+      () => this.resolveScheduledFlush("idle_timeout"),
       getJitteredWaitMs(IDLE_FLUSH_WAIT_MS, IDLE_FLUSH_JITTER_RATIO)
     );
   }
-  resolveScheduledFlush() {
+  resolveScheduledFlush(reason) {
     this.clearTimeouts();
-    this.resolveWait?.();
+    this.resolveWait?.(reason);
   }
   reset() {
     this.pending = null;
     this.resolveWait = null;
-    this.count = 0;
     this.clearTimeouts();
   }
   clearTimeouts() {
@@ -1109,10 +1127,6 @@ var FlagsEvaluationEvent = class {
 };
 
 // src/utils/usage-tracker.ts
-function evaluationsDisabled() {
-  const value = process.env.VERCEL_FLAGS_ENABLE_METRICS?.toLowerCase();
-  return value !== "true";
-}
 var UsageTracker = class {
   flushCount = 0;
   options;
@@ -1122,7 +1136,7 @@ var UsageTracker = class {
   evaluationEvents = /* @__PURE__ */ new Map();
   constructor(options) {
     this.options = options;
-    this.scheduler = new Scheduler(() => this.flushEvents());
+    this.scheduler = new Scheduler((reason) => this.flushEvents(reason));
   }
   /**
    * Triggers an immediate flush of any pending events.
@@ -1130,7 +1144,7 @@ var UsageTracker = class {
    */
   async shutdown() {
     await this.scheduler.shutdown();
-    await this.flushEvents();
+    await this.flushEvents("shutdown");
   }
   /**
    * Tracks a config read event. Deduplicates by request context.
@@ -1143,7 +1157,6 @@ var UsageTracker = class {
       this.trackedRequests.add(ctx);
       this.readEvents.push(new FlagsConfigReadEvent(headers, options));
       this.scheduler.scheduleFlush();
-      this.scheduler.increment();
     } catch (error) {
       console.error("@vercel/flags-core: Failed to record event:", error);
     }
@@ -1153,9 +1166,6 @@ var UsageTracker = class {
    */
   trackEvaluation(options) {
     try {
-      if (evaluationsDisabled()) {
-        return;
-      }
       const bucketedOptions = {
         ...options,
         bucketTs: minuteBucketTs()
@@ -1169,7 +1179,6 @@ var UsageTracker = class {
           batchKey,
           new FlagsEvaluationEvent(bucketedOptions)
         );
-        this.scheduler.increment();
       }
       this.scheduler.scheduleFlush();
     } catch (error) {
@@ -1182,14 +1191,14 @@ var UsageTracker = class {
   /**
    * Send all events to the ingest service
    */
-  async flushEvents() {
+  async flushEvents(flushReason) {
     const events = [...this.readEvents, ...this.evaluationEvents.values()];
     if (events.length === 0) return;
     this.flushCount += 1;
     const flushId = this.flushCount;
     this.readEvents = [];
     this.evaluationEvents.clear();
-    await sendIngestEvents(this.options, events, flushId);
+    await sendIngestEvents(this.options, events, flushId, flushReason);
   }
 };
 
@@ -1347,7 +1356,8 @@ function normalizeOptions(options) {
     buildStep,
     fetch: options.fetch ?? globalThis.fetch,
     host: "https://flags.vercel.com",
-    clientName: options.clientName
+    clientName: options.clientName,
+    disableMetrics: options.disableMetrics ?? false
   };
 }
 
@@ -2318,7 +2328,7 @@ var Controller = class {
    * Tracks a flag evaluation for usage analytics.
    */
   trackEvaluation(options) {
-    if (this.unauthorized) return;
+    if (this.unauthorized || this.options.disableMetrics) return;
     this.usageTracker.trackEvaluation({
       ...options,
       clientName: options.clientName ?? this.options.clientName
@@ -2494,4 +2504,4 @@ export {
   resetDefaultFlagsClient,
   createClient
 };
-//# sourceMappingURL=chunk-ETOLBVKS.js.map
+//# sourceMappingURL=chunk-3QHXSGEW.js.map