@vercel/flags-core 1.0.1 → 1.1.0-3ca407e-20260306094417

package/dist/chunk-WRX7DC3S.cjs

@@ -0,0 +1,1982 @@
+"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
+var _cache = require('next/cache');
+
+// src/evaluate.ts
+var _jsxxhash = require('js-xxhash');
+
+// src/types.ts
+var ResolutionReason = /* @__PURE__ */ ((ResolutionReason2) => {
+  ResolutionReason2["PAUSED"] = "paused";
+  ResolutionReason2["TARGET_MATCH"] = "target_match";
+  ResolutionReason2["RULE_MATCH"] = "rule_match";
+  ResolutionReason2["FALLTHROUGH"] = "fallthrough";
+  ResolutionReason2["ERROR"] = "error";
+  return ResolutionReason2;
+})(ResolutionReason || {});
+var Original;
+((Original2) => {
+  let AccessorType;
+  ((AccessorType2) => {
+    AccessorType2["SEGMENT"] = "segment";
+    AccessorType2["ENTITY"] = "entity";
+  })(AccessorType = Original2.AccessorType || (Original2.AccessorType = {}));
+})(Original || (Original = {}));
+var Packed;
+((Packed2) => {
+  let AccessorType;
+  ((AccessorType2) => {
+    AccessorType2["SEGMENT"] = "segment";
+    AccessorType2["ENTITY"] = "entity";
+  })(AccessorType = Packed2.AccessorType || (Packed2.AccessorType = {}));
+})(Packed || (Packed = {}));
+
+// src/evaluate.ts
+var MAX_REGEX_INPUT_LENGTH = 1e4;
+function exhaustivenessCheck(_) {
+  throw new Error("Exhaustiveness check failed");
+}
+function getProperty(obj, pathArray) {
+  return pathArray.reduce((acc, key) => {
+    if (acc && key in acc) {
+      return acc[key];
+    }
+    return void 0;
+  }, obj);
+}
+function access(lhs, params) {
+  if (Array.isArray(lhs)) return getProperty(params.entities, lhs);
+  if (lhs === Packed.AccessorType.SEGMENT)
+    throw new Error("Unexpected segment");
+  throw new Error("Accessor not implemented");
+}
+function isString(input) {
+  return typeof input === "string";
+}
+function isNumber(input) {
+  return typeof input === "number";
+}
+function isArray(input) {
+  return Array.isArray(input);
+}
+function lower(input) {
+  if (typeof input === "string") return input.toLowerCase();
+  if (Array.isArray(input)) return input.map(lower);
+  return input;
+}
+var IGNORE_CASE_COMPARATORS = /* @__PURE__ */ new Set([
+  "eq" /* EQ */,
+  "!eq" /* NOT_EQ */,
+  "oneOf" /* ONE_OF */,
+  "!oneOf" /* NOT_ONE_OF */,
+  "containsAllOf" /* CONTAINS_ALL_OF */,
+  "containsAnyOf" /* CONTAINS_ANY_OF */,
+  "containsNoneOf" /* CONTAINS_NONE_OF */,
+  "startsWith" /* STARTS_WITH */,
+  "!startsWith" /* NOT_STARTS_WITH */,
+  "endsWith" /* ENDS_WITH */,
+  "!endsWith" /* NOT_ENDS_WITH */,
+  "contains" /* CONTAINS */,
+  "!contains" /* NOT_CONTAINS */
+]);
+function matchTargetList(targets, params) {
+  for (const kind in targets) {
+    const attributes = targets[kind];
+    for (const attribute in attributes) {
+      const entity = access([kind, attribute], params);
+      if (isString(entity) && attributes[attribute].includes(entity))
+        return true;
+    }
+  }
+  return false;
+}
+function matchSegment(segment, params) {
+  if (segment.include && matchTargetList(segment.include, params)) return true;
+  if (segment.exclude && matchTargetList(segment.exclude, params)) return false;
+  if (!_optionalChain([segment, 'access', _2 => _2.rules, 'optionalAccess', _3 => _3.length])) return false;
+  const firstMatchingRule = segment.rules.find(
+    (rule) => matchConditions(rule.conditions, params)
+  );
+  if (!firstMatchingRule) return false;
+  return handleSegmentOutcome(params, firstMatchingRule.outcome);
+}
+function matchSegmentCondition(cmp, rhs, params) {
+  switch (cmp) {
+    case "eq" /* EQ */: {
+      const segment = _optionalChain([params, 'access', _4 => _4.segments, 'optionalAccess', _5 => _5[rhs]]);
+      if (!segment) return false;
+      return matchSegment(segment, params);
+    }
+    case "!eq" /* NOT_EQ */: {
+      const segment = _optionalChain([params, 'access', _6 => _6.segments, 'optionalAccess', _7 => _7[rhs]]);
+      if (!segment) return false;
+      return !matchSegment(segment, params);
+    }
+    case "oneOf" /* ONE_OF */: {
+      if (!isArray(rhs)) return false;
+      const segmentIds = rhs;
+      return segmentIds.some((segmentId) => {
+        const segment = _optionalChain([params, 'access', _8 => _8.segments, 'optionalAccess', _9 => _9[segmentId]]);
+        if (!segment) return false;
+        return matchSegment(segment, params);
+      });
+    }
+    case "!oneOf" /* NOT_ONE_OF */: {
+      const segmentIds = rhs;
+      return segmentIds.every((segmentId) => {
+        const segment = _optionalChain([params, 'access', _10 => _10.segments, 'optionalAccess', _11 => _11[segmentId]]);
+        if (!segment) return false;
+        return !matchSegment(segment, params);
+      });
+    }
+    default:
+      throw new Error(`Comparator ${cmp} not implemented for segment`);
+  }
+}
+function matchConditions(conditions, params) {
+  return conditions.every((condition) => {
+    const [lhsAccessor, cmpKey, rawRhs, options] = condition;
+    const hasIgnoreCaseFlag = typeof options === "string" && options.includes("i");
+    const hasIgnoreCaseOption = typeof options === "object" && options !== null && options.i === true;
+    const ignoreCase = IGNORE_CASE_COMPARATORS.has(cmpKey) && (hasIgnoreCaseFlag || hasIgnoreCaseOption);
+    if (lhsAccessor === Packed.AccessorType.SEGMENT) {
+      return rawRhs && matchSegmentCondition(cmpKey, rawRhs, params);
+    }
+    const lhs = ignoreCase ? lower(access(lhsAccessor, params)) : access(lhsAccessor, params);
+    const rhs = ignoreCase ? lower(rawRhs) : rawRhs;
+    try {
+      switch (cmpKey) {
+        case "eq" /* EQ */:
+          return lhs === rhs;
+        case "!eq" /* NOT_EQ */:
+          return lhs !== rhs;
+        case "oneOf" /* ONE_OF */:
+          return isArray(rhs) && rhs.includes(lhs);
+        case "!oneOf" /* NOT_ONE_OF */:
+          return isArray(rhs) && typeof lhs !== "undefined" && !rhs.includes(lhs);
+        case "containsAllOf" /* CONTAINS_ALL_OF */: {
+          if (!Array.isArray(rhs) || !Array.isArray(lhs)) return false;
+          const lhsSet = new Set(lhs.filter(isString));
+          if (lhsSet.size === lhs.length) {
+            return rhs.filter(isString).every((item) => lhsSet.has(item));
+          }
+          return rhs.every((item) => lhs.includes(item));
+        }
+        case "containsAnyOf" /* CONTAINS_ANY_OF */: {
+          if (!Array.isArray(rhs) || !Array.isArray(lhs)) return false;
+          const rhsSet = new Set(rhs.filter(isString));
+          return lhs.some(
+            rhsSet.size === rhs.length ? (
+              // try to use a set if the rhs is a list of strings - O(1)
+              (item) => rhsSet.has(item)
+            ) : (
+              // otherwise we need to iterate over the values - O(n)
+              (item) => rhs.includes(item)
+            )
+          );
+        }
+        case "containsNoneOf" /* CONTAINS_NONE_OF */: {
+          if (!Array.isArray(rhs)) return false;
+          if (!Array.isArray(lhs)) return true;
+          const rhsSet = new Set(rhs.filter(isString));
+          return lhs.every(
+            rhsSet.size === rhs.length ? (
+              // try to use a set if the rhs is a list of strings - O(1)
+              (item) => !rhsSet.has(item)
+            ) : (
+              // otherwise we need to iterate over the values - O(n)
+              (item) => !rhs.includes(item)
+            )
+          );
+        }
+        case "startsWith" /* STARTS_WITH */:
+          return isString(lhs) && isString(rhs) && lhs.startsWith(rhs);
+        case "!startsWith" /* NOT_STARTS_WITH */:
+          return isString(lhs) && isString(rhs) && !lhs.startsWith(rhs);
+        case "endsWith" /* ENDS_WITH */:
+          return isString(lhs) && isString(rhs) && lhs.endsWith(rhs);
+        case "!endsWith" /* NOT_ENDS_WITH */:
+          return isString(lhs) && isString(rhs) && !lhs.endsWith(rhs);
+        case "contains" /* CONTAINS */:
+          return isString(lhs) && isString(rhs) && lhs.includes(rhs);
+        case "!contains" /* NOT_CONTAINS */:
+          return isString(lhs) && isString(rhs) && !lhs.includes(rhs);
+        case "ex" /* EXISTS */:
+          return lhs !== void 0 && lhs !== null;
+        case "!ex" /* NOT_EXISTS */:
+          return lhs === void 0 || lhs === null;
+        case "gt" /* GT */:
+          if (lhs === null || lhs === void 0) return false;
+          return (isNumber(rhs) || isString(rhs)) && lhs > rhs;
+        case "gte" /* GTE */:
+          if (lhs === null || lhs === void 0) return false;
+          return (isNumber(rhs) || isString(rhs)) && lhs >= rhs;
+        case "lt" /* LT */:
+          if (lhs === null || lhs === void 0) return false;
+          return (isNumber(rhs) || isString(rhs)) && lhs < rhs;
+        case "lte" /* LTE */:
+          if (lhs === null || lhs === void 0) return false;
+          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 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 false;
+        case "before" /* BEFORE */: {
+          if (!isString(lhs) || !isString(rhs)) return false;
+          const a = new Date(lhs);
+          const b = new Date(rhs);
+          return a.getTime() < b.getTime();
+        }
+        case "after" /* AFTER */: {
+          if (!isString(lhs) || !isString(rhs)) return false;
+          const a = new Date(lhs);
+          const b = new Date(rhs);
+          return a.getTime() > b.getTime();
+        }
+        default: {
+          const _x = cmpKey;
+          return false;
+        }
+      }
+    } catch (error) {
+      console.error("flags: Error matching conditions", error);
+      return false;
+    }
+  });
+}
+function sum(list) {
+  return list.reduce((acc, n) => acc + n, 0);
+}
+function handleSegmentOutcome(params, outcome) {
+  if (outcome === 1) return true;
+  switch (outcome.type) {
+    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 = _jsxxhash.xxHash32.call(void 0, lhs, params.definition.seed) % maxValue;
+      return value < outcome.passPromille;
+    }
+    default: {
+      const { type } = outcome;
+      exhaustivenessCheck(type);
+    }
+  }
+}
+function getVariant(variants, index) {
+  if (index < 0 || index >= variants.length) {
+    throw new Error(
+      `@vercel/flags-core: Invalid variant index ${index}, variants length is ${variants.length}`
+    );
+  }
+  return variants[index];
+}
+function handleOutcome(params, outcome) {
+  if (typeof outcome === "number") {
+    return {
+      value: getVariant(params.definition.variants, outcome),
+      outcomeType: "value" /* VALUE */
+    };
+  }
+  switch (outcome.type) {
+    case "split": {
+      const lhs = access(outcome.base, params);
+      const defaultOutcome = getVariant(
+        params.definition.variants,
+        outcome.defaultVariant
+      );
+      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);
+      return {
+        value: variantIndex === -1 ? defaultOutcome : getVariant(params.definition.variants, variantIndex),
+        outcomeType: "split" /* SPLIT */
+      };
+    }
+    default: {
+      const { type } = outcome;
+      exhaustivenessCheck(type);
+    }
+  }
+}
+function evaluate(params, _visited) {
+  const envConfig = params.definition.environments[params.environment];
+  if (typeof envConfig === "number") {
+    return Object.assign(handleOutcome(params, envConfig), {
+      reason: "paused" /* PAUSED */
+    });
+  }
+  if (!envConfig) {
+    return {
+      reason: "error" /* ERROR */,
+      errorMessage: `Could not find envConfig for "${params.environment}"`,
+      value: params.defaultValue
+    };
+  }
+  if ("reuse" in envConfig) {
+    const reuseEnvConfig = params.definition.environments[envConfig.reuse];
+    if (reuseEnvConfig === void 0) {
+      throw new Error(
+        `Could not find envConfig for "${envConfig.reuse}" when reusing`
+      );
+    }
+    const visited = _nullishCoalesce(_visited, () => ( /* @__PURE__ */ new Set()));
+    if (visited.has(envConfig.reuse)) {
+      return {
+        reason: "error" /* ERROR */,
+        errorMessage: `Circular environment reuse detected: "${envConfig.reuse}"`,
+        value: params.defaultValue
+      };
+    }
+    visited.add(params.environment);
+    return evaluate({ ...params, environment: envConfig.reuse }, visited);
+  }
+  if (envConfig.targets) {
+    const matchedIndex = envConfig.targets.findIndex(
+      (targetList) => matchTargetList(targetList, params)
+    );
+    if (matchedIndex > -1) {
+      return Object.assign(handleOutcome(params, matchedIndex), {
+        reason: "target_match" /* TARGET_MATCH */
+      });
+    }
+  }
+  const firstMatchingRule = envConfig.rules ? envConfig.rules.find((rule) => matchConditions(rule.conditions, params)) : void 0;
+  if (firstMatchingRule) {
+    return Object.assign(handleOutcome(params, firstMatchingRule.outcome), {
+      reason: "rule_match" /* RULE_MATCH */
+    });
+  }
+  return Object.assign(handleOutcome(params, envConfig.fallthrough), {
+    reason: "fallthrough" /* FALLTHROUGH */
+  });
+}
+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.1.0-3ca407e-20260306094417";
+
+// src/lib/report-value.ts
+function internalReportValue(key, value, data) {
+  const symbol = /* @__PURE__ */ Symbol.for("@vercel/request-context");
+  const ctx = _optionalChain([Reflect, 'access', _14 => _14.get, 'call', _15 => _15(globalThis, symbol), 'optionalAccess', _16 => _16.get, 'call', _17 => _17()]);
+  _optionalChain([ctx, 'optionalAccess', _18 => _18.flags, 'optionalAccess', _19 => _19.reportValue, 'call', _20 => _20(key, value, {
+    sdkVersion: version,
+    ...data
+  })]);
+}
+
+// src/controller-fns.ts
+var controllerInstanceMap = /* @__PURE__ */ new Map();
+function getInstance(id) {
+  const instance = controllerInstanceMap.get(id);
+  if (!instance) {
+    throw new Error(
+      `@vercel/flags-core: Client instance ${id} not found. It may have been shut down.`
+    );
+  }
+  return instance;
+}
+function initialize(id) {
+  return getInstance(id).controller.initialize();
+}
+function shutdown(id) {
+  return getInstance(id).controller.shutdown();
+}
+function getDatafile(id) {
+  return getInstance(id).controller.getDatafile();
+}
+function getFallbackDatafile(id) {
+  const ds = getInstance(id).controller;
+  if (ds.getFallbackDatafile) return ds.getFallbackDatafile();
+  throw new Error("flags: This data source does not support fallbacks");
+}
+async function evaluate2(id, flagKey, defaultValue, entities) {
+  const controller = getInstance(id).controller;
+  let datafile;
+  try {
+    datafile = await controller.read();
+  } catch (error) {
+    if (defaultValue !== void 0) {
+      return {
+        value: defaultValue,
+        reason: "error" /* ERROR */,
+        errorMessage: error instanceof Error ? error.message : "Failed to read datafile"
+      };
+    }
+    throw error;
+  }
+  const flagDefinition = datafile.definitions[flagKey];
+  if (flagDefinition === void 0) {
+    if (datafile.projectId) {
+      internalReportValue(flagKey, defaultValue, {
+        originProjectId: datafile.projectId,
+        originProvider: "vercel",
+        reason: "error" /* ERROR */
+      });
+    }
+    return {
+      value: defaultValue,
+      reason: "error" /* ERROR */,
+      errorCode: "FLAG_NOT_FOUND" /* FLAG_NOT_FOUND */,
+      errorMessage: `@vercel/flags-core: Definition not found for flag "${flagKey}"`,
+      metrics: {
+        evaluationMs: 0,
+        readMs: datafile.metrics.readMs,
+        source: datafile.metrics.source,
+        cacheStatus: datafile.metrics.cacheStatus,
+        connectionState: datafile.metrics.connectionState,
+        mode: datafile.metrics.mode
+      }
+    };
+  }
+  const evalStartTime = Date.now();
+  const result = evaluate({
+    defaultValue,
+    definition: flagDefinition,
+    environment: datafile.environment,
+    entities: _nullishCoalesce(entities, () => ( {})),
+    segments: datafile.segments
+  });
+  const evaluationDurationMs = Date.now() - evalStartTime;
+  if (datafile.projectId) {
+    internalReportValue(flagKey, result.value, {
+      originProjectId: datafile.projectId,
+      originProvider: "vercel",
+      reason: result.reason,
+      outcomeType: result.reason !== "error" /* ERROR */ ? result.outcomeType : void 0
+    });
+  }
+  return Object.assign(result, {
+    metrics: {
+      evaluationMs: evaluationDurationMs,
+      readMs: datafile.metrics.readMs,
+      source: datafile.metrics.source,
+      cacheStatus: datafile.metrics.cacheStatus,
+      connectionState: datafile.metrics.connectionState,
+      mode: datafile.metrics.mode
+    }
+  });
+}
+
+// src/create-raw-client.ts
+var idCount = 0;
+async function performInitialize(instance, initFn) {
+  try {
+    await initFn();
+    instance.initialized = true;
+  } catch (error) {
+    instance.initPromise = null;
+    throw error;
+  }
+}
+function createCreateRawClient(fns) {
+  return function createRawClient({
+    controller,
+    origin
+  }) {
+    const id = idCount++;
+    controllerInstanceMap.set(id, {
+      controller,
+      initialized: false,
+      initPromise: null
+    });
+    const api = {
+      origin,
+      initialize: async () => {
+        let instance = controllerInstanceMap.get(id);
+        if (!instance) {
+          instance = { controller, initialized: false, initPromise: null };
+          controllerInstanceMap.set(id, instance);
+        }
+        if (instance.initialized) return;
+        if (!instance.initPromise) {
+          instance.initPromise = performInitialize(
+            instance,
+            () => fns.initialize(id)
+          );
+        }
+        return instance.initPromise;
+      },
+      shutdown: async () => {
+        await fns.shutdown(id);
+        controllerInstanceMap.delete(id);
+      },
+      getDatafile: async () => {
+        const instance = controllerInstanceMap.get(id);
+        if (_optionalChain([instance, 'optionalAccess', _21 => _21.initPromise])) {
+          try {
+            await instance.initPromise;
+          } catch (e) {
+          }
+        }
+        return fns.getDatafile(id);
+      },
+      getFallbackDatafile: () => {
+        return fns.getFallbackDatafile(id);
+      },
+      evaluate: async (flagKey, defaultValue, entities) => {
+        const instance = controllerInstanceMap.get(id);
+        if (!_optionalChain([instance, 'optionalAccess', _22 => _22.initialized])) {
+          try {
+            await api.initialize();
+          } catch (e2) {
+          }
+        }
+        return fns.evaluate(id, flagKey, defaultValue, entities);
+      }
+    };
+    return api;
+  };
+}
+
+// src/utils/read-bundled-definitions.ts
+var sdkKeyHashCache = /* @__PURE__ */ new Map();
+async function computeHash(sdkKey) {
+  const hashBuffer = await crypto.subtle.digest(
+    "SHA-256",
+    new TextEncoder().encode(sdkKey)
+  );
+  const hashArray = new Uint8Array(hashBuffer);
+  return Array.from(hashArray).map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+function hashSdkKey(sdkKey) {
+  const cached = sdkKeyHashCache.get(sdkKey);
+  if (cached) return cached;
+  const promise = computeHash(sdkKey);
+  sdkKeyHashCache.set(sdkKey, promise);
+  return promise;
+}
+async function readBundledDefinitions(sdkKey) {
+  let get;
+  try {
+    const module = await Promise.resolve().then(() => _interopRequireWildcard(require(
+      /* turbopackOptional: true */
+      // @ts-expect-error this only exists at build time
+      "@vercel/flags-definitions"
+    )));
+    get = module.get;
+  } catch (error) {
+    if (error && typeof error === "object" && "code" in error && error.code === "MODULE_NOT_FOUND") {
+      return { definitions: null, state: "missing-file" };
+    }
+    return { definitions: null, state: "unexpected-error", error };
+  }
+  const entry = get(sdkKey);
+  if (entry) return { definitions: entry, state: "ok" };
+  try {
+    const hashedKey = await hashSdkKey(sdkKey);
+    const hashedEntry = get(hashedKey);
+    if (hashedEntry) return { definitions: hashedEntry, state: "ok" };
+  } catch (error) {
+    return { definitions: null, state: "unexpected-error", error };
+  }
+  return { definitions: null, state: "missing-entry" };
+}
+
+// src/utils/usage-tracker.ts
+var _functions = require('@vercel/functions');
+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")]);
+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 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()]);
+    if (ctx && Object.hasOwn(ctx, "headers")) {
+      return {
+        ctx,
+        headers: ctx.headers
+      };
+    }
+    return { ctx, headers: void 0 };
+  } catch (e3) {
+    return { ctx: void 0, headers: void 0 };
+  }
+}
+var UsageTracker = (_class = class {
+  __init() {this.flushCounter = 0}
+  
+  __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);
+    this.options = options;
+  }
+  /**
+   * 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;
+  }
+  /**
+   * Tracks a config read event. Deduplicates by request context.
+   */
+  trackRead(options) {
+    try {
+      const { ctx, headers } = getRequestContext();
+      if (ctx) {
+        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;
+      }
+      this.batcher.events.push(event);
+      this.scheduleFlush();
+    } 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, MAX_BATCH_WAIT_MS);
+        });
+        this.batcher.pending = null;
+        this.batcher.resolveWait = null;
+        if (timeout) clearTimeout(timeout);
+        await this.flushEvents();
+      })();
+      try {
+        _functions.waitUntil.call(void 0, pending);
+      } catch (e4) {
+      }
+      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()]);
+    }
+  }
+  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 response = await this.options.fetch(
+          `${this.options.host}/v1/ingest`,
+          {
+            method: "POST",
+            headers: {
+              "Content-Type": "application/json",
+              Authorization: `Bearer ${this.options.sdkKey}`,
+              "User-Agent": `VercelFlagsCore/${version}`,
+              ...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) {
+          await new Promise((res) => setTimeout(res, attempt * 100));
+        }
+      }
+    }
+  }
+}, _class);
+
+// src/errors.ts
+var FallbackNotFoundError = class extends Error {
+  constructor() {
+    super("@vercel/flags-core: Bundled definitions file not found.");
+    this.name = "FallbackNotFoundError";
+  }
+};
+var FallbackEntryNotFoundError = class extends Error {
+  constructor() {
+    super("@vercel/flags-core: No bundled definitions found for SDK key.");
+    this.name = "FallbackEntryNotFoundError";
+  }
+};
+
+// src/controller/bundled-source.ts
+var BundledSource = class {
+  
+  
+  constructor(options) {
+    this.options = options;
+  }
+  /**
+   * Load bundled definitions.
+   * Throws if bundled definitions are not available.
+   */
+  async load() {
+    const result = await this.getResult();
+    if (result.state === "ok" && result.definitions) {
+      return result.definitions;
+    }
+    throw new Error(
+      "@vercel/flags-core: No flag definitions available. Bundled definitions not found."
+    );
+  }
+  /**
+   * Get the raw BundledDefinitions (for getFallbackDatafile).
+   * Throws typed errors if not available.
+   */
+  async getRaw() {
+    const result = await this.getResult();
+    switch (result.state) {
+      case "ok":
+        return result.definitions;
+      case "missing-file":
+        throw new FallbackNotFoundError();
+      case "missing-entry":
+        throw new FallbackEntryNotFoundError();
+      case "unexpected-error":
+        throw new Error(
+          "@vercel/flags-core: Failed to read bundled definitions: " + String(result.error)
+        );
+    }
+  }
+  /**
+   * Check if bundled definitions loaded successfully (without throwing).
+   */
+  async tryLoad() {
+    const result = await this.getResult();
+    if (_optionalChain([result, 'optionalAccess', _36 => _36.state]) === "ok" && result.definitions) {
+      return result.definitions;
+    }
+    return void 0;
+  }
+  getResult() {
+    if (!this.promise) {
+      this.promise = this.options.readBundledDefinitions(this.options.sdkKey);
+    }
+    return this.promise;
+  }
+};
+
+// src/controller/fetch-datafile.ts
+var DEFAULT_FETCH_TIMEOUT_MS = 1e4;
+async function fetchDatafile(options) {
+  const controller = new AbortController();
+  const timeoutId = setTimeout(
+    () => controller.abort(),
+    DEFAULT_FETCH_TIMEOUT_MS
+  );
+  const onExternalAbort = () => controller.abort();
+  if (options.signal) {
+    if (options.signal.aborted) {
+      clearTimeout(timeoutId);
+      throw new Error("Fetch aborted");
+    }
+    options.signal.addEventListener("abort", onExternalAbort, { once: true });
+  }
+  try {
+    const res = await options.fetch(`${options.host}/v1/datafile`, {
+      headers: {
+        Authorization: `Bearer ${options.sdkKey}`,
+        "User-Agent": `VercelFlagsCore/${version}`
+      },
+      signal: controller.signal
+    });
+    clearTimeout(timeoutId);
+    _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', _40 => _40.signal, 'optionalAccess', _41 => _41.removeEventListener, 'call', _42 => _42("abort", onExternalAbort)]);
+    throw error instanceof Error ? error : new Error("Unknown fetch error");
+  }
+}
+
+// src/controller/normalized-options.ts
+var DEFAULT_STREAM_INIT_TIMEOUT_MS = 3e3;
+var DEFAULT_POLLING_INTERVAL_MS = 3e4;
+var MIN_POLLING_INTERVAL_MS = 3e4;
+var DEFAULT_POLLING_INIT_TIMEOUT_MS = 3e3;
+function normalizeOptions(options) {
+  const autoDetectedBuildStep = process.env.CI === "1" || process.env.NEXT_PHASE === "phase-production-build";
+  const buildStep = _nullishCoalesce(options.buildStep, () => ( autoDetectedBuildStep));
+  let stream;
+  if (options.stream === void 0 || options.stream === true) {
+    stream = { enabled: true, initTimeoutMs: DEFAULT_STREAM_INIT_TIMEOUT_MS };
+  } else if (options.stream === false) {
+    stream = { enabled: false, initTimeoutMs: 0 };
+  } else {
+    stream = { enabled: true, initTimeoutMs: options.stream.initTimeoutMs };
+  }
+  let polling;
+  if (options.polling === void 0 || options.polling === true) {
+    polling = {
+      enabled: true,
+      intervalMs: DEFAULT_POLLING_INTERVAL_MS,
+      initTimeoutMs: DEFAULT_POLLING_INIT_TIMEOUT_MS
+    };
+  } else if (options.polling === false) {
+    polling = { enabled: false, intervalMs: 0, initTimeoutMs: 0 };
+  } else {
+    if (options.polling.intervalMs < MIN_POLLING_INTERVAL_MS) {
+      throw new Error(
+        `@vercel/flags-core: Polling interval must be at least ${MIN_POLLING_INTERVAL_MS}ms, got ${options.polling.intervalMs}ms.`
+      );
+    }
+    polling = {
+      enabled: true,
+      intervalMs: options.polling.intervalMs,
+      initTimeoutMs: options.polling.initTimeoutMs
+    };
+  }
+  return {
+    sdkKey: options.sdkKey,
+    datafile: options.datafile,
+    stream,
+    polling,
+    buildStep,
+    fetch: _nullishCoalesce(options.fetch, () => ( globalThis.fetch)),
+    host: "https://flags.vercel.com"
+  };
+}
+
+// src/controller/typed-emitter.ts
+var TypedEmitter = (_class2 = class {constructor() { _class2.prototype.__init4.call(this); }
+  __init4() {this.handlers = /* @__PURE__ */ new Map()}
+  on(event, handler) {
+    let set = this.handlers.get(event);
+    if (!set) {
+      set = /* @__PURE__ */ new Set();
+      this.handlers.set(event, set);
+    }
+    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)]);
+  }
+  emit(event, ...args) {
+    const set = this.handlers.get(event);
+    if (set) {
+      for (const handler of set) {
+        handler(...args);
+      }
+    }
+  }
+}, _class2);
+
+// src/controller/polling-source.ts
+var PollingSource = class extends TypedEmitter {
+  
+  
+  
+  constructor(config) {
+    super();
+    this.config = config;
+  }
+  /**
+   * Perform a single poll request.
+   * 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;
+    try {
+      const data = await fetchDatafile({
+        ...this.config,
+        signal: _optionalChain([this, 'access', _51 => _51.abortController, 'optionalAccess', _52 => _52.signal])
+      });
+      this.emit("data", data);
+    } catch (error) {
+      const err = error instanceof Error ? error : new Error("Unknown poll error");
+      this.emit("error", err);
+    }
+  }
+  /**
+   * Start interval-based polling.
+   * Polls at the configured interval. Does not perform an initial poll —
+   * callers should call poll() first if an immediate poll is needed.
+   */
+  startInterval() {
+    if (this.intervalId) return;
+    this.abortController = new AbortController();
+    this.intervalId = setInterval(
+      () => void this.poll(),
+      this.config.polling.intervalMs
+    );
+  }
+  /**
+   * Stop interval-based polling.
+   */
+  stop() {
+    if (this.intervalId) {
+      clearInterval(this.intervalId);
+      this.intervalId = void 0;
+    }
+    _optionalChain([this, 'access', _53 => _53.abortController, 'optionalAccess', _54 => _54.abort, 'call', _55 => _55()]);
+    this.abortController = void 0;
+  }
+};
+
+// src/utils/sleep.ts
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// src/controller/stream-connection.ts
+var MAX_RETRY_COUNT = 15;
+var BASE_RETRY_DELAY_MS = 1e3;
+var MAX_RETRY_DELAY_MS = 6e4;
+var PING_TIMEOUT_MS = 9e4;
+function backoff(retryCount) {
+  if (retryCount === 1) return 0;
+  const delay = Math.min(
+    BASE_RETRY_DELAY_MS * 2 ** (retryCount - 2),
+    MAX_RETRY_DELAY_MS
+  );
+  return delay + Math.random() * 1e3;
+}
+var UnauthorizedError = class extends Error {
+  constructor() {
+    super("stream: unauthorized (401)");
+    this.name = "UnauthorizedError";
+  }
+};
+async function connectStream(config, callbacks) {
+  const {
+    host,
+    sdkKey,
+    abortController,
+    fetch: fetchFn = globalThis.fetch
+  } = config;
+  const { onDatafile, onPrimed, onDisconnect } = callbacks;
+  let retryCount = 0;
+  let lastAttemptTime = 0;
+  let resolveInit;
+  let rejectInit;
+  const initPromise = new Promise((resolve, reject) => {
+    resolveInit = resolve;
+    rejectInit = reject;
+  });
+  void (async () => {
+    let initialDataReceived = false;
+    while (!abortController.signal.aborted) {
+      if (retryCount > MAX_RETRY_COUNT) {
+        console.error("@vercel/flags-core: Max retry count exceeded");
+        if (!initialDataReceived) {
+          rejectInit(
+            new Error("stream: max retry count exceeded before receiving data")
+          );
+        }
+        abortController.abort();
+        break;
+      }
+      const connectionAbort = new AbortController();
+      const onMainAbort = () => connectionAbort.abort();
+      abortController.signal.addEventListener("abort", onMainAbort, {
+        once: true
+      });
+      let pingTimeoutId;
+      let responseBody;
+      const resetPingTimeout = () => {
+        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(() => {
+          })]);
+          connectionAbort.abort();
+        }, PING_TIMEOUT_MS);
+      };
+      try {
+        lastAttemptTime = Date.now();
+        const headers = {
+          Authorization: `Bearer ${sdkKey}`,
+          "User-Agent": `VercelFlagsCore/${version}`,
+          "X-Retry-Attempt": String(retryCount)
+        };
+        const revision = _optionalChain([config, 'access', _60 => _60.revision, 'optionalCall', _61 => _61()]);
+        if (revision !== void 0) {
+          headers["X-Revision"] = String(revision);
+        }
+        const response = await fetchFn(`${host}/v1/stream`, {
+          headers,
+          signal: connectionAbort.signal
+        });
+        if (!response.ok) {
+          if (response.status === 401) {
+            if (!initialDataReceived) {
+              rejectInit(new UnauthorizedError());
+            }
+            abortController.abort();
+            break;
+          }
+          throw new Error(`stream was not ok: ${response.status}`);
+        }
+        if (!response.body) {
+          throw new Error("stream body was not present");
+        }
+        responseBody = response.body;
+        const reader = response.body.getReader();
+        const decoder = new TextDecoder();
+        const bufferChunks = [];
+        const onConnectionAbort = () => {
+          reader.cancel().catch(() => {
+          });
+        };
+        connectionAbort.signal.addEventListener("abort", onConnectionAbort, {
+          once: true
+        });
+        try {
+          while (true) {
+            const { done, value: chunk } = await reader.read();
+            if (done || abortController.signal.aborted) break;
+            bufferChunks.push(decoder.decode(chunk, { stream: true }));
+            const combined = bufferChunks.join("");
+            bufferChunks.length = 0;
+            const lines = combined.split("\n");
+            bufferChunks.push(lines.pop());
+            for (const line of lines) {
+              if (line === "") continue;
+              let message;
+              try {
+                message = JSON.parse(line);
+              } catch (e5) {
+                console.warn(
+                  "@vercel/flags-core: Failed to parse stream message, skipping"
+                );
+                continue;
+              }
+              if (message.type === "datafile") {
+                onDatafile(message.data);
+                retryCount = 0;
+                if (!initialDataReceived) {
+                  initialDataReceived = true;
+                  resolveInit();
+                }
+                resetPingTimeout();
+              }
+              if (message.type === "primed") {
+                _optionalChain([onPrimed, 'optionalCall', _62 => _62(message)]);
+                retryCount = 0;
+                if (!initialDataReceived) {
+                  initialDataReceived = true;
+                  resolveInit();
+                }
+                resetPingTimeout();
+              }
+              if (message.type === "ping" && initialDataReceived) {
+                retryCount = 0;
+                resetPingTimeout();
+              }
+            }
+          }
+        } finally {
+          connectionAbort.signal.removeEventListener(
+            "abort",
+            onConnectionAbort
+          );
+        }
+        clearTimeout(pingTimeoutId);
+        abortController.signal.removeEventListener("abort", onMainAbort);
+        if (!abortController.signal.aborted) {
+          _optionalChain([onDisconnect, 'optionalCall', _63 => _63()]);
+          retryCount++;
+          const elapsed = Date.now() - lastAttemptTime;
+          const minGap = Math.max(0, BASE_RETRY_DELAY_MS - elapsed);
+          await sleep(Math.max(backoff(retryCount), minGap));
+          continue;
+        }
+      } catch (error) {
+        clearTimeout(pingTimeoutId);
+        abortController.signal.removeEventListener("abort", onMainAbort);
+        if (abortController.signal.aborted) {
+          break;
+        }
+        if (!connectionAbort.signal.aborted) {
+          console.error("@vercel/flags-core: Stream error", error);
+        }
+        _optionalChain([onDisconnect, 'optionalCall', _64 => _64()]);
+        retryCount++;
+        const elapsed = Date.now() - lastAttemptTime;
+        const minGap = Math.max(0, BASE_RETRY_DELAY_MS - elapsed);
+        await sleep(Math.max(backoff(retryCount), minGap));
+      }
+    }
+    if (!initialDataReceived) {
+      rejectInit(new Error("stream: aborted before receiving data"));
+    }
+  })();
+  return initPromise;
+}
+
+// src/controller/stream-source.ts
+var StreamSource = class extends TypedEmitter {
+  
+  
+  
+  
+  constructor(options, revision) {
+    super();
+    this.options = options;
+    this.revision = revision;
+  }
+  /**
+   * Start the stream connection.
+   * Returns a promise that resolves when the first datafile or primed message arrives.
+   * If already started, returns the existing promise.
+   */
+  start() {
+    if (this.promise) return this.promise;
+    const abortController = new AbortController();
+    this.abortController = abortController;
+    abortController.signal.addEventListener(
+      "abort",
+      () => {
+        if (this.abortController === abortController) {
+          this.promise = void 0;
+          this.abortController = void 0;
+        }
+      },
+      { once: true }
+    );
+    try {
+      const promise = connectStream(
+        {
+          host: this.options.host,
+          sdkKey: this.options.sdkKey,
+          abortController,
+          fetch: this.options.fetch,
+          revision: this.revision
+        },
+        {
+          onDatafile: (newData) => {
+            this.emit("data", newData);
+            this.emit("connected");
+          },
+          onPrimed: (message) => {
+            this.emit("primed", message);
+            this.emit("connected");
+          },
+          onDisconnect: () => {
+            this.emit("disconnected");
+          }
+        }
+      );
+      this.promise = promise;
+      return promise;
+    } catch (error) {
+      this.promise = void 0;
+      this.abortController = void 0;
+      throw error;
+    }
+  }
+  /**
+   * Stop the stream connection.
+   */
+  stop() {
+    _optionalChain([this, 'access', _65 => _65.abortController, 'optionalAccess', _66 => _66.abort, 'call', _67 => _67()]);
+    this.abortController = void 0;
+    this.promise = void 0;
+  }
+};
+
+// src/controller/tagged-data.ts
+function tagData(data, origin) {
+  return Object.assign(data, { _origin: origin });
+}
+function originToMetricsSource(origin) {
+  switch (origin) {
+    case "stream":
+    case "poll":
+    case "provided":
+      return "in-memory";
+    case "fetched":
+      return "remote";
+    case "bundled":
+      return "embedded";
+  }
+}
+
+// src/controller/index.ts
+function parseConfigUpdatedAt(value) {
+  if (typeof value === "number") return value;
+  if (typeof value === "string") {
+    const parsed = Number(value);
+    return Number.isNaN(parsed) ? void 0 : parsed;
+  }
+  return void 0;
+}
+var Controller = (_class3 = class {
+  
+  // State machine
+  __init5() {this.state = "idle"}
+  // Data state — tagged with origin
+  
+  // Sources (I/O delegates)
+  
+  
+  
+  // Usage tracking
+  
+  __init6() {this.isFirstGetData = true}
+  // Build-step deduplication
+  __init7() {this.buildDataPromise = null}
+  __init8() {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);
+    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_"'
+      );
+    }
+    this.options = normalizeOptions(options);
+    this.streamSource = new StreamSource(
+      this.options,
+      () => _optionalChain([this, 'access', _68 => _68.data, 'optionalAccess', _69 => _69.revision])
+    );
+    this.pollingSource = new PollingSource(this.options);
+    this.bundledSource = new BundledSource({
+      sdkKey: this.options.sdkKey,
+      readBundledDefinitions
+    });
+    this.wireSourceEvents();
+    if (this.options.datafile) {
+      this.data = tagData(this.options.datafile, "provided");
+    }
+    this.usageTracker = new UsageTracker(this.options);
+  }
+  // Source event handlers (stored for cleanup)
+  __init10() {this.onStreamData = (data) => {
+    if (this.isNewerData(data)) {
+      this.data = tagData(data, "stream");
+    }
+  }}
+  __init11() {this.onStreamPrimed = () => {
+    if (this.state === "degraded" || this.state === "initializing:stream") {
+      this.transition("streaming");
+    }
+  }}
+  __init12() {this.onStreamConnected = () => {
+    if (this.state === "degraded" || this.state === "initializing:stream") {
+      this.transition("streaming");
+    }
+  }}
+  __init13() {this.onStreamDisconnected = () => {
+    if (this.state === "streaming") {
+      this.transition("degraded");
+    }
+  }}
+  __init14() {this.onPollData = (data) => {
+    if (this.isNewerData(data)) {
+      this.data = tagData(data, "poll");
+    }
+  }}
+  __init15() {this.onPollError = (error) => {
+    console.error("@vercel/flags-core: Poll failed:", error);
+  }}
+  // ---------------------------------------------------------------------------
+  // Source event wiring
+  // ---------------------------------------------------------------------------
+  wireSourceEvents() {
+    this.streamSource.on("data", this.onStreamData);
+    this.streamSource.on("primed", this.onStreamPrimed);
+    this.streamSource.on("connected", this.onStreamConnected);
+    this.streamSource.on("disconnected", this.onStreamDisconnected);
+    this.pollingSource.on("data", this.onPollData);
+    this.pollingSource.on("error", this.onPollError);
+  }
+  unwireSourceEvents() {
+    this.streamSource.off("data", this.onStreamData);
+    this.streamSource.off("primed", this.onStreamPrimed);
+    this.streamSource.off("connected", this.onStreamConnected);
+    this.streamSource.off("disconnected", this.onStreamDisconnected);
+    this.pollingSource.off("data", this.onPollData);
+    this.pollingSource.off("error", this.onPollError);
+  }
+  // ---------------------------------------------------------------------------
+  // State machine
+  // ---------------------------------------------------------------------------
+  transition(to) {
+    this.state = to;
+  }
+  get isConnected() {
+    return this.state === "streaming";
+  }
+  get mode() {
+    if (this.options.buildStep) return "build";
+    switch (this.state) {
+      case "streaming":
+        return "streaming";
+      case "polling":
+        return "polling";
+      default:
+        return "offline";
+    }
+  }
+  // ---------------------------------------------------------------------------
+  // Public API (DataSource interface)
+  // ---------------------------------------------------------------------------
+  /**
+   * Initializes the data source.
+   *
+   * Build step: datafile → bundled → one-time fetch
+   * Streaming mode: stream → datafile → bundled
+   * Polling mode (no stream): poll → datafile → bundled
+   * Offline mode (neither): datafile → bundled → one-time fetch
+   */
+  async initialize() {
+    if (this.options.buildStep) {
+      this.transition("build:loading");
+      await this.initializeForBuildStep();
+      this.transition("build:ready");
+      return;
+    }
+    if (!this.data && this.options.datafile) {
+      this.data = tagData(this.options.datafile, "provided");
+    }
+    if (!this.data) {
+      try {
+        const bundled = await this.bundledSource.tryLoad();
+        if (bundled) {
+          this.data = tagData(bundled, "bundled");
+        }
+      } catch (e6) {
+      }
+    }
+    if (this.data) {
+      if (this.options.stream.enabled) {
+        this.transition("initializing:stream");
+        await this.tryInitializeStream();
+      } else if (this.options.polling.enabled) {
+        this.transition("initializing:polling");
+        await this.tryInitializePolling();
+      } else {
+        this.transition("degraded");
+      }
+      return;
+    }
+    if (this.options.stream.enabled) {
+      this.transition("initializing:stream");
+      const streamSuccess = await this.tryInitializeStream();
+      if (streamSuccess) {
+        this.transition("streaming");
+        return;
+      }
+    } else if (this.options.polling.enabled) {
+      this.transition("initializing:polling");
+      const pollingSuccess = await this.tryInitializePolling();
+      if (pollingSuccess) {
+        this.transition("polling");
+        return;
+      }
+    }
+    await this.initializeFromFallbacks();
+  }
+  /**
+   * Reads the current datafile with metrics.
+   */
+  async read() {
+    const startTime = Date.now();
+    const cacheHadDefinitions = this.data !== void 0;
+    const isFirstRead = this.isFirstGetData;
+    this.isFirstGetData = false;
+    const [result, cacheStatus] = await this.resolveData();
+    const readMs = Date.now() - startTime;
+    const { _origin, ...data } = result;
+    const source = originToMetricsSource(_origin);
+    this.trackRead(startTime, cacheHadDefinitions, isFirstRead, source);
+    return {
+      ...data,
+      metrics: {
+        readMs,
+        source,
+        cacheStatus,
+        connectionState: this.isConnected ? "connected" : "disconnected",
+        mode: this.mode
+      }
+    };
+  }
+  /**
+   * Shuts down the data source and releases resources.
+   */
+  async shutdown() {
+    this.unwireSourceEvents();
+    this.streamSource.stop();
+    this.pollingSource.stop();
+    this.data = this.options.datafile ? tagData(this.options.datafile, "provided") : void 0;
+    this.transition("shutdown");
+    await this.usageTracker.flush();
+  }
+  /**
+   * Returns the datafile with metrics.
+   * Uses in-memory data if available, otherwise falls back to bundled,
+   * then to a one-time fetch if called without prior initialization.
+   */
+  async getDatafile() {
+    const startTime = Date.now();
+    this.isFirstGetData = false;
+    let result;
+    let cacheStatus;
+    if (this.options.buildStep) {
+      [result, cacheStatus] = await this.resolveDataForBuildStep();
+    } else if (this.data) {
+      cacheStatus = this.isConnected ? "HIT" : "STALE";
+      result = this.data;
+    } else {
+      const bundled = await this.bundledSource.tryLoad();
+      if (bundled) {
+        this.data = tagData(bundled, "bundled");
+        result = this.data;
+        cacheStatus = "MISS";
+      } else {
+        try {
+          const fetched = await fetchDatafile({
+            host: this.options.host,
+            sdkKey: this.options.sdkKey,
+            fetch: this.options.fetch
+          });
+          this.data = tagData(fetched, "fetched");
+          result = this.data;
+          cacheStatus = "MISS";
+        } catch (e7) {
+          throw new Error(
+            "@vercel/flags-core: No flag definitions available. Initialize the client or provide a datafile."
+          );
+        }
+      }
+    }
+    const source = originToMetricsSource(result._origin);
+    return {
+      ...result,
+      metrics: {
+        readMs: Date.now() - startTime,
+        source,
+        cacheStatus,
+        connectionState: this.isConnected ? "connected" : "disconnected",
+        mode: this.mode
+      }
+    };
+  }
+  /**
+   * Returns the bundled fallback datafile.
+   */
+  async getFallbackDatafile() {
+    return this.bundledSource.getRaw();
+  }
+  // ---------------------------------------------------------------------------
+  // Data resolution (shared by read() and getDatafile())
+  // ---------------------------------------------------------------------------
+  /**
+   * Resolves the current data, using the appropriate strategy for the
+   * current mode. Returns tagged data and cache status.
+   *
+   * Build step: cached → bundled → one-time fetch
+   * Runtime with cache: return cached data
+   * Runtime without cache: stream/poll → datafile → bundled → fetch → throw
+   */
+  async resolveData() {
+    if (this.options.buildStep) {
+      return this.resolveDataForBuildStep();
+    }
+    if (this.data) {
+      const cacheStatus = this.isConnected ? "HIT" : "STALE";
+      return [this.data, cacheStatus];
+    }
+    return this.resolveDataWithFallbacks();
+  }
+  // ---------------------------------------------------------------------------
+  // Stream initialization
+  // ---------------------------------------------------------------------------
+  /**
+   * Attempts to initialize via stream with timeout.
+   * Returns true if stream connected successfully within timeout.
+   */
+  async tryInitializeStream() {
+    if (this.options.stream.initTimeoutMs <= 0) {
+      try {
+        await this.streamSource.start();
+        return true;
+      } catch (error) {
+        if (error instanceof UnauthorizedError) {
+          this.unauthorized = true;
+        }
+        return false;
+      }
+    }
+    let timeoutId;
+    const timeoutPromise = new Promise((resolve) => {
+      timeoutId = setTimeout(
+        () => resolve("timeout"),
+        this.options.stream.initTimeoutMs
+      );
+    });
+    try {
+      const result = await Promise.race([
+        this.streamSource.start(),
+        timeoutPromise
+      ]);
+      clearTimeout(timeoutId);
+      if (result === "timeout") {
+        console.warn(
+          "@vercel/flags-core: Stream initialization timeout, falling back"
+        );
+        void this.streamSource.start().catch(() => {
+        });
+        return false;
+      }
+      return true;
+    } catch (error) {
+      clearTimeout(timeoutId);
+      if (error instanceof Error && error.message.includes("401")) {
+        this.unauthorized = true;
+      }
+      return false;
+    }
+  }
+  // ---------------------------------------------------------------------------
+  // Polling initialization
+  // ---------------------------------------------------------------------------
+  /**
+   * Attempts to initialize via polling with timeout.
+   * Returns true if first poll succeeded within timeout.
+   *
+   * Only used when streaming is disabled and polling is the primary source.
+   */
+  async tryInitializePolling() {
+    const pollPromise = this.pollingSource.poll();
+    if (this.options.polling.initTimeoutMs <= 0) {
+      try {
+        await pollPromise;
+        if (this.data) {
+          this.pollingSource.startInterval();
+          return true;
+        }
+        return false;
+      } catch (e8) {
+        return false;
+      }
+    }
+    let timeoutId;
+    const timeoutPromise = new Promise((resolve) => {
+      timeoutId = setTimeout(
+        () => resolve("timeout"),
+        this.options.polling.initTimeoutMs
+      );
+    });
+    try {
+      const result = await Promise.race([pollPromise, timeoutPromise]);
+      clearTimeout(timeoutId);
+      if (result === "timeout") {
+        console.warn(
+          "@vercel/flags-core: Polling initialization timeout, falling back"
+        );
+        return false;
+      }
+      if (this.data) {
+        this.pollingSource.startInterval();
+        return true;
+      }
+      return false;
+    } catch (e9) {
+      clearTimeout(timeoutId);
+      return false;
+    }
+  }
+  // ---------------------------------------------------------------------------
+  // Build step helpers
+  // ---------------------------------------------------------------------------
+  /**
+   * Initializes data for build step environments.
+   */
+  async initializeForBuildStep() {
+    if (this.data) return;
+    if (!this.buildDataPromise) {
+      this.buildDataPromise = this.loadBuildData();
+    }
+    this.data = await this.buildDataPromise;
+  }
+  /**
+   * Retrieves data during build steps.
+   * Concurrent callers share a single load promise. The first caller to
+   * populate `this.data` gets cacheStatus MISS; subsequent callers get HIT.
+   */
+  async resolveDataForBuildStep() {
+    if (this.data) {
+      return [this.data, "HIT"];
+    }
+    if (!this.buildDataPromise) {
+      this.buildDataPromise = this.loadBuildData();
+    }
+    const data = await this.buildDataPromise;
+    if (!this.data) {
+      this.data = data;
+      return [data, "MISS"];
+    }
+    return [this.data, "HIT"];
+  }
+  /**
+   * Loads data for a build step: bundled → one-time fetch.
+   */
+  async loadBuildData() {
+    const bundled = await this.bundledSource.tryLoad();
+    if (bundled) return tagData(bundled, "bundled");
+    try {
+      const fetched = await fetchDatafile({
+        host: this.options.host,
+        sdkKey: this.options.sdkKey,
+        fetch: this.options.fetch
+      });
+      return tagData(fetched, "fetched");
+    } catch (e10) {
+    }
+    throw new Error(
+      "@vercel/flags-core: No flag definitions available during build. Provide a datafile or bundled definitions."
+    );
+  }
+  // ---------------------------------------------------------------------------
+  // Fallback helpers
+  // ---------------------------------------------------------------------------
+  /**
+   * Shared fallback chain used by both initialize() and resolveData().
+   */
+  async initializeFromFallbacks() {
+    this.transition("initializing:fallback");
+    if (this.data) {
+      this.transition("degraded");
+      return;
+    }
+    const bundled = await this.bundledSource.tryLoad();
+    if (bundled) {
+      this.data = tagData(bundled, "bundled");
+      this.transition("degraded");
+      return;
+    }
+    if (!this.options.stream.enabled && !this.options.polling.enabled) {
+      try {
+        const fetched = await fetchDatafile({
+          host: this.options.host,
+          sdkKey: this.options.sdkKey,
+          fetch: this.options.fetch
+        });
+        this.data = tagData(fetched, "fetched");
+        this.transition("degraded");
+        return;
+      } catch (e11) {
+      }
+    }
+    throw new Error(
+      "@vercel/flags-core: No flag definitions available. Bundled definitions not found."
+    );
+  }
+  /**
+   * Retrieves data using the fallback chain (called when no cached data exists).
+   * Streaming mode: stream → datafile → bundled.
+   * Polling mode: poll → datafile → bundled.
+   * Offline mode: datafile → bundled → one-time fetch.
+   */
+  async resolveDataWithFallbacks() {
+    if (this.options.stream.enabled) {
+      this.transition("initializing:stream");
+      const streamSuccess = await this.tryInitializeStream();
+      if (streamSuccess && this.data) {
+        this.transition("streaming");
+        return [this.data, "MISS"];
+      }
+    } else if (this.options.polling.enabled) {
+      this.transition("initializing:polling");
+      const pollingSuccess = await this.tryInitializePolling();
+      if (pollingSuccess && this.data) {
+        this.transition("polling");
+        return [this.data, "MISS"];
+      }
+    }
+    this.transition("initializing:fallback");
+    if (this.options.datafile) {
+      this.data = tagData(this.options.datafile, "provided");
+      this.transition("degraded");
+      return [this.data, "STALE"];
+    }
+    const bundled = await this.bundledSource.tryLoad();
+    if (bundled) {
+      console.warn("@vercel/flags-core: Using bundled definitions as fallback");
+      this.data = tagData(bundled, "bundled");
+      this.transition("degraded");
+      return [this.data, "STALE"];
+    }
+    if (!this.options.stream.enabled && !this.options.polling.enabled) {
+      try {
+        const fetched = await fetchDatafile({
+          host: this.options.host,
+          sdkKey: this.options.sdkKey,
+          fetch: this.options.fetch
+        });
+        this.data = tagData(fetched, "fetched");
+        this.transition("degraded");
+        return [this.data, "MISS"];
+      } catch (e12) {
+      }
+    }
+    throw new Error(
+      "@vercel/flags-core: No flag definitions available. Provide a datafile or bundled definitions."
+    );
+  }
+  // ---------------------------------------------------------------------------
+  // Data comparison
+  // ---------------------------------------------------------------------------
+  /**
+   * Checks if the incoming data is newer than the current in-memory data.
+   * Returns true if the update should proceed, false if it should be skipped.
+   *
+   * Always accepts the update if:
+   * - There is no current data
+   * - The current data has no configUpdatedAt
+   * - The incoming data has no configUpdatedAt
+   *
+   * Skips the update only when both have configUpdatedAt and incoming is not newer.
+   */
+  isNewerData(incoming) {
+    if (!this.data) return true;
+    const currentTs = parseConfigUpdatedAt(this.data.configUpdatedAt);
+    const incomingTs = parseConfigUpdatedAt(incoming.configUpdatedAt);
+    if (currentTs === void 0 || incomingTs === void 0) {
+      return true;
+    }
+    return incomingTs > currentTs;
+  }
+  // ---------------------------------------------------------------------------
+  // Usage tracking
+  // ---------------------------------------------------------------------------
+  /**
+   * Tracks a read operation for usage analytics.
+   * During build steps, only the first read is tracked.
+   */
+  trackRead(startTime, cacheHadDefinitions, isFirstRead, source) {
+    if (this.unauthorized) return;
+    if (this.options.buildStep && this.buildReadTracked) return;
+    if (this.options.buildStep) this.buildReadTracked = true;
+    const configOrigin = source === "embedded" ? "embedded" : "in-memory";
+    const cacheAction = this.state === "streaming" ? "FOLLOWING" : this.state === "polling" ? "REFRESHING" : "NONE";
+    const mode = this.mode;
+    const trackOptions = {
+      configOrigin,
+      cacheStatus: cacheHadDefinitions ? "HIT" : "MISS",
+      cacheAction,
+      cacheIsBlocking: !cacheHadDefinitions,
+      duration: Date.now() - startTime,
+      mode: mode === "streaming" ? "stream" : mode === "polling" ? "poll" : mode
+    };
+    const configUpdatedAt = _optionalChain([this, 'access', _70 => _70.data, 'optionalAccess', _71 => _71.configUpdatedAt]);
+    if (typeof configUpdatedAt === "number") {
+      trackOptions.configUpdatedAt = configUpdatedAt;
+    }
+    const revision = _optionalChain([this, 'access', _72 => _72.data, 'optionalAccess', _73 => _73.revision]);
+    if (typeof revision === "number") {
+      trackOptions.revision = revision;
+    }
+    if (isFirstRead) {
+      trackOptions.cacheIsFirstRead = true;
+    }
+    this.usageTracker.trackRead(trackOptions);
+  }
+}, _class3);
+
+// src/utils/sdk-keys.ts
+function parseSdkKeyFromFlagsConnectionString(text) {
+  if (text.startsWith("vf_")) return text;
+  try {
+    if (!text.startsWith("flags:")) return null;
+    const params = new URLSearchParams(text.slice(6));
+    return params.get("sdkKey");
+  } catch (e13) {
+  }
+  return null;
+}
+
+// src/index.make.ts
+function make(createRawClient) {
+  let _defaultFlagsClient = null;
+  function createClient2(sdkKeyOrConnectionString, options) {
+    if (!sdkKeyOrConnectionString)
+      throw new Error("@vercel/flags-core: Missing sdkKey");
+    if (typeof sdkKeyOrConnectionString !== "string")
+      throw new Error(
+        `@vercel/flags-core: Invalid sdkKey. Expected string, got ${typeof sdkKeyOrConnectionString}`
+      );
+    const sdkKey = parseSdkKeyFromFlagsConnectionString(
+      sdkKeyOrConnectionString
+    );
+    if (!sdkKey) {
+      throw new Error(
+        "@vercel/flags-core: Missing sdkKey in connection string"
+      );
+    }
+    const controller = new Controller({ sdkKey, ...options });
+    return createRawClient({
+      controller,
+      origin: { provider: "vercel", sdkKey }
+    });
+  }
+  function resetDefaultFlagsClient2() {
+    _defaultFlagsClient = null;
+  }
+  const flagsClient2 = new Proxy({}, {
+    get(_, prop) {
+      if (!_defaultFlagsClient) {
+        if (!process.env.FLAGS) {
+          throw new Error("flags: Missing environment variable FLAGS");
+        }
+        const sdkKey = parseSdkKeyFromFlagsConnectionString(process.env.FLAGS);
+        if (!sdkKey) {
+          throw new Error("@vercel/flags-core: Missing sdkKey");
+        }
+        _defaultFlagsClient = createClient2(sdkKey);
+      }
+      return _defaultFlagsClient[prop];
+    }
+  });
+  return {
+    flagsClient: flagsClient2,
+    resetDefaultFlagsClient: resetDefaultFlagsClient2,
+    createClient: createClient2
+  };
+}
+
+// src/index.next-js.ts
+function setCacheLife() {
+  try {
+    _cache.cacheLife.call(void 0, { revalidate: 0, expire: 0 });
+    _cache.cacheLife.call(void 0, { stale: 60 });
+  } catch (e14) {
+  }
+}
+var cachedFns = {
+  initialize: async (...args) => {
+    "use cache";
+    setCacheLife();
+    return initialize(...args);
+  },
+  shutdown: async (...args) => {
+    "use cache";
+    setCacheLife();
+    return shutdown(...args);
+  },
+  getDatafile: async (...args) => {
+    "use cache";
+    setCacheLife();
+    return getDatafile(...args);
+  },
+  getFallbackDatafile: async (...args) => {
+    "use cache";
+    setCacheLife();
+    return getFallbackDatafile(...args);
+  },
+  evaluate: async (...args) => {
+    "use cache";
+    setCacheLife();
+    return evaluate2(...args);
+  }
+};
+var { flagsClient, resetDefaultFlagsClient, createClient } = make(
+  createCreateRawClient(cachedFns)
+);
+
+
+
+
+
+
+
+
+
+
+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-WRX7DC3S.cjs.map