@vercel/flags-core 0.1.8 → 1.0.0

package/dist/chunk-7BUTND2Q.js

@@ -0,0 +1,1496 @@
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/client-fns.ts
+var client_fns_exports = {};
+__export(client_fns_exports, {
+  evaluate: () => evaluate2,
+  getDatafile: () => getDatafile,
+  getFallbackDatafile: () => getFallbackDatafile,
+  initialize: () => initialize,
+  shutdown: () => shutdown
+});
+
+// src/client-map.ts
+var clientMap = /* @__PURE__ */ new Map();
+
+// src/evaluate.ts
+import { xxHash32 as hashInput } from "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/utils.ts
+function exhaustivenessCheck(_) {
+  throw new Error("Exhaustiveness check failed");
+}
+
+// src/evaluate.ts
+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 matchTargetList(targets, params) {
+  for (const [kind, attributes] of Object.entries(targets)) {
+    for (const [attribute, values] of Object.entries(attributes)) {
+      const entity = access([kind, attribute], params);
+      if (isString(entity) && values.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 (!segment.rules?.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 = params.segments?.[rhs];
+      if (!segment) return false;
+      return matchSegment(segment, params);
+    }
+    case "!eq" /* NOT_EQ */: {
+      const segment = params.segments?.[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 = params.segments?.[segmentId];
+        if (!segment) return false;
+        return matchSegment(segment, params);
+      });
+    }
+    case "!oneOf" /* NOT_ONE_OF */: {
+      const segmentIds = rhs;
+      return segmentIds.every((segmentId) => {
+        const segment = params.segments?.[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, rhs] = condition;
+    if (lhsAccessor === Packed.AccessorType.SEGMENT) {
+      return rhs && matchSegmentCondition(cmpKey, rhs, params);
+    }
+    const lhs = access(lhsAccessor, params);
+    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 "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) && typeof rhs === "object" && !Array.isArray(rhs) && rhs?.type === "regex") {
+            return new RegExp(rhs.pattern, rhs.flags).test(lhs);
+          }
+          return false;
+        case "!regex" /* NOT_REGEX */:
+          if (isString(lhs) && typeof rhs === "object" && !Array.isArray(rhs) && rhs?.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 = hashInput(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 = hashInput(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) {
+  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`
+      );
+    }
+    return evaluate({ ...params, environment: envConfig.reuse });
+  }
+  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.0.0";
+
+// src/lib/report-value.ts
+function internalReportValue(key, value, data) {
+  const symbol = /* @__PURE__ */ Symbol.for("@vercel/request-context");
+  const ctx = Reflect.get(globalThis, symbol)?.get();
+  ctx?.flags?.reportValue(key, value, {
+    sdkVersion: version,
+    ...data
+  });
+}
+
+// src/client-fns.ts
+function initialize(id) {
+  return clientMap.get(id).dataSource.initialize();
+}
+function shutdown(id) {
+  return clientMap.get(id).dataSource.shutdown();
+}
+function getDatafile(id) {
+  return clientMap.get(id).dataSource.getDatafile();
+}
+function getFallbackDatafile(id) {
+  const ds = clientMap.get(id).dataSource;
+  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 ds = clientMap.get(id).dataSource;
+  const datafile = await ds.read();
+  const flagDefinition = datafile.definitions[flagKey];
+  if (flagDefinition === void 0) {
+    return {
+      value: defaultValue,
+      reason: "error" /* ERROR */,
+      errorCode: "FLAG_NOT_FOUND" /* FLAG_NOT_FOUND */,
+      errorMessage: `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
+      }
+    };
+  }
+  const evalStartTime = Date.now();
+  const result = evaluate({
+    defaultValue,
+    definition: flagDefinition,
+    environment: datafile.environment,
+    entities: 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
+    }
+  });
+}
+
+// src/create-raw-client.ts
+var idCount = 0;
+function createCreateRawClient(fns) {
+  return function createRawClient({
+    dataSource,
+    origin
+  }) {
+    const id = idCount++;
+    clientMap.set(id, { dataSource, initialized: false });
+    const api = {
+      origin,
+      initialize: async () => {
+        let instance = clientMap.get(id);
+        if (!instance) {
+          instance = { dataSource, initialized: false };
+          clientMap.set(id, instance);
+        }
+        if (instance.initialized) return;
+        const promise = fns.initialize(id);
+        await promise;
+        instance.initialized = true;
+        return promise;
+      },
+      shutdown: async () => {
+        await fns.shutdown(id);
+        clientMap.delete(id);
+      },
+      getDatafile: () => fns.getDatafile(id),
+      getFallbackDatafile: () => {
+        return fns.getFallbackDatafile(id);
+      },
+      evaluate: async (flagKey, defaultValue, entities) => {
+        const instance = clientMap.get(id);
+        if (!instance?.initialized) await api.initialize();
+        return fns.evaluate(id, flagKey, defaultValue, entities);
+      }
+    };
+    return api;
+  };
+}
+
+// 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/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 import(
+      /* 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/sleep.ts
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// src/utils/usage-tracker.ts
+import { waitUntil } from "@vercel/functions";
+var RESOLVED_VOID = Promise.resolve();
+var isDebugMode = process.env.DEBUG?.includes("@vercel/flags-core");
+var debugLog = (...args) => {
+  if (!isDebugMode) return;
+  console.log(...args);
+};
+var MAX_BATCH_SIZE = 50;
+var MAX_BATCH_WAIT_MS = 5e3;
+var trackedRequests = /* @__PURE__ */ new WeakSet();
+var SYMBOL_FOR_REQ_CONTEXT = /* @__PURE__ */ Symbol.for("@vercel/request-context");
+var fromSymbol = globalThis;
+function getRequestContext() {
+  try {
+    const ctx = fromSymbol[SYMBOL_FOR_REQ_CONTEXT]?.get?.();
+    if (ctx && Object.hasOwn(ctx, "headers")) {
+      return {
+        ctx,
+        headers: ctx.headers
+      };
+    }
+    return { ctx, headers: void 0 };
+  } catch {
+    return { ctx: void 0, headers: void 0 };
+  }
+}
+var UsageTracker = class {
+  sdkKey;
+  host;
+  batcher = {
+    events: [],
+    resolveWait: null,
+    pending: null
+  };
+  constructor(options) {
+    this.sdkKey = options.sdkKey;
+    this.host = options.host;
+  }
+  /**
+   * Triggers an immediate flush of any pending events.
+   * Returns a promise that resolves when the flush completes.
+   */
+  flush() {
+    this.batcher.resolveWait?.();
+    return this.batcher.pending ?? RESOLVED_VOID;
+  }
+  /**
+   * Tracks a config read event. Deduplicates by request context.
+   */
+  trackRead(options) {
+    try {
+      const { ctx, headers } = getRequestContext();
+      if (ctx) {
+        if (trackedRequests.has(ctx)) return;
+        trackedRequests.add(ctx);
+      }
+      const event = {
+        type: "FLAGS_CONFIG_READ",
+        ts: Date.now(),
+        payload: {
+          deploymentId: process.env.VERCEL_DEPLOYMENT_ID,
+          region: process.env.VERCEL_REGION
+        }
+      };
+      if (headers) {
+        event.payload.vercelRequestId = headers["x-vercel-id"] ?? void 0;
+        event.payload.invocationHost = headers.host ?? void 0;
+      }
+      if (options) {
+        event.payload.configOrigin = options.configOrigin;
+        if (options.cacheStatus !== void 0) {
+          event.payload.cacheStatus = options.cacheStatus;
+        }
+        if (options.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;
+        }
+      }
+      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();
+      })();
+      waitUntil(pending);
+      this.batcher.pending = pending;
+    }
+    if (this.batcher.events.length >= MAX_BATCH_SIZE) {
+      this.batcher.resolveWait?.();
+    }
+  }
+  async flushEvents() {
+    if (this.batcher.events.length === 0) return;
+    const eventsToSend = this.batcher.events;
+    this.batcher.events = [];
+    try {
+      const response = await fetch(`${this.host}/v1/ingest`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${this.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) {
+        debugLog(
+          "@vercel/flags-core: Failed to send events:",
+          response.statusText
+        );
+      }
+    } catch (error) {
+      debugLog("@vercel/flags-core: Error sending events:", error);
+    }
+  }
+};
+
+// src/data-source/stream-connection.ts
+var MAX_RETRY_COUNT = 15;
+var BASE_DELAY_MS = 1e3;
+var MAX_DELAY_MS = 6e4;
+function backoff(retryCount) {
+  if (retryCount === 1) return 0;
+  const delay = Math.min(BASE_DELAY_MS * 2 ** (retryCount - 2), MAX_DELAY_MS);
+  return delay + Math.random() * 1e3;
+}
+async function connectStream(config, callbacks) {
+  const {
+    host,
+    sdkKey,
+    abortController,
+    fetch: fetchFn = globalThis.fetch
+  } = config;
+  const { onMessage, onDisconnect } = callbacks;
+  let retryCount = 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");
+        abortController.abort();
+        break;
+      }
+      try {
+        const response = await fetchFn(`${host}/v1/stream`, {
+          headers: {
+            Authorization: `Bearer ${sdkKey}`,
+            "User-Agent": `VercelFlagsCore/${version}`,
+            "X-Retry-Attempt": String(retryCount)
+          },
+          signal: abortController.signal
+        });
+        if (!response.ok) {
+          if (response.status === 401) {
+            abortController.abort();
+          }
+          throw new Error(`stream was not ok: ${response.status}`);
+        }
+        if (!response.body) {
+          throw new Error("stream body was not present");
+        }
+        const decoder = new TextDecoder();
+        let buffer = "";
+        for await (const chunk of response.body) {
+          if (abortController.signal.aborted) break;
+          buffer += decoder.decode(chunk, { stream: true });
+          const lines = buffer.split("\n");
+          buffer = lines.pop();
+          for (const line of lines) {
+            if (line === "") continue;
+            let message;
+            try {
+              message = JSON.parse(line);
+            } catch {
+              console.warn(
+                "@vercel/flags-core: Failed to parse stream message, skipping"
+              );
+              continue;
+            }
+            if (message.type === "datafile") {
+              onMessage(message.data);
+              retryCount = 0;
+              if (!initialDataReceived) {
+                initialDataReceived = true;
+                resolveInit();
+              }
+            }
+          }
+        }
+        if (!abortController.signal.aborted) {
+          onDisconnect?.();
+          retryCount++;
+          await sleep(backoff(retryCount));
+          continue;
+        }
+      } catch (error) {
+        if (abortController.signal.aborted) {
+          break;
+        }
+        console.error("@vercel/flags-core: Stream error", error);
+        onDisconnect?.();
+        if (!initialDataReceived) {
+          rejectInit(error);
+          break;
+        }
+        retryCount++;
+        await sleep(backoff(retryCount));
+      }
+    }
+  })();
+  return initPromise;
+}
+
+// src/data-source/flag-network-data-source.ts
+var FLAGS_HOST = "https://flags.vercel.com";
+var DEFAULT_STREAM_INIT_TIMEOUT_MS = 3e3;
+var DEFAULT_POLLING_INTERVAL_MS = 3e4;
+var DEFAULT_POLLING_INIT_TIMEOUT_MS = 3e3;
+var DEFAULT_FETCH_TIMEOUT_MS = 1e4;
+var MAX_FETCH_RETRIES = 3;
+var FETCH_RETRY_BASE_DELAY_MS = 500;
+function normalizeOptions(options) {
+  const autoDetectedBuildStep = process.env.CI === "1" || process.env.NEXT_PHASE === "phase-production-build";
+  const buildStep = 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 {
+    polling = {
+      enabled: true,
+      intervalMs: options.polling.intervalMs,
+      initTimeoutMs: options.polling.initTimeoutMs
+    };
+  }
+  return {
+    sdkKey: options.sdkKey,
+    datafile: options.datafile,
+    stream,
+    polling,
+    buildStep,
+    fetch: options.fetch ?? globalThis.fetch
+  };
+}
+async function fetchDatafile(host, sdkKey, fetchFn) {
+  let lastError;
+  for (let attempt = 0; attempt < MAX_FETCH_RETRIES; attempt++) {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(
+      () => controller.abort(),
+      DEFAULT_FETCH_TIMEOUT_MS
+    );
+    let shouldRetry = true;
+    try {
+      const res = await fetchFn(`${host}/v1/datafile`, {
+        headers: {
+          Authorization: `Bearer ${sdkKey}`,
+          "User-Agent": `VercelFlagsCore/${version}`
+        },
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      if (!res.ok) {
+        if (res.status >= 400 && res.status < 500 && res.status !== 429) {
+          shouldRetry = false;
+        }
+        throw new Error(`Failed to fetch data: ${res.statusText}`);
+      }
+      return res.json();
+    } catch (error) {
+      clearTimeout(timeoutId);
+      lastError = error instanceof Error ? error : new Error("Unknown fetch error");
+      if (!shouldRetry) throw lastError;
+      if (attempt < MAX_FETCH_RETRIES - 1) {
+        const delay = FETCH_RETRY_BASE_DELAY_MS * 2 ** attempt + Math.random() * 500;
+        await sleep(delay);
+      }
+    }
+  }
+  throw lastError ?? new Error("Failed to fetch data after retries");
+}
+var FlagNetworkDataSource = class _FlagNetworkDataSource {
+  options;
+  host = FLAGS_HOST;
+  // Data state
+  data;
+  bundledDefinitionsPromise;
+  // Stream state
+  streamAbortController;
+  streamPromise;
+  isStreamConnected = false;
+  hasWarnedAboutStaleData = false;
+  // Polling state
+  pollingIntervalId;
+  pollingAbortController;
+  // Usage tracking
+  usageTracker;
+  isFirstGetData = true;
+  /**
+   * Creates a new FlagNetworkDataSource instance.
+   */
+  constructor(options) {
+    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.bundledDefinitionsPromise = readBundledDefinitions(
+      this.options.sdkKey
+    );
+    if (this.options.datafile) {
+      this.data = this.options.datafile;
+    }
+    this.usageTracker = new UsageTracker({
+      sdkKey: this.options.sdkKey,
+      host: this.host
+    });
+  }
+  // ---------------------------------------------------------------------------
+  // Public API (DataSource interface)
+  // ---------------------------------------------------------------------------
+  /**
+   * Initializes the data source.
+   *
+   * Build step: datafile → bundled → fetch
+   * Runtime: stream → poll → datafile → bundled
+   */
+  async initialize() {
+    if (this.options.buildStep) {
+      await this.initializeForBuildStep();
+      return;
+    }
+    if (!this.data && this.options.datafile) {
+      this.data = this.options.datafile;
+    }
+    if (this.data) {
+      this.startBackgroundUpdates();
+      return;
+    }
+    if (this.options.stream.enabled) {
+      const streamSuccess = await this.tryInitializeStream();
+      if (streamSuccess) return;
+    }
+    if (this.options.polling.enabled) {
+      const pollingSuccess = await this.tryInitializePolling();
+      if (pollingSuccess) return;
+    }
+    if (this.data) return;
+    await this.initializeFromBundled();
+  }
+  /**
+   * Reads the current datafile with metrics.
+   */
+  async read() {
+    const startTime = Date.now();
+    const cachedData = this.data;
+    const cacheHadDefinitions = cachedData !== void 0;
+    const isFirstRead = this.isFirstGetData;
+    this.isFirstGetData = false;
+    let result;
+    let source;
+    let cacheStatus;
+    if (this.options.buildStep) {
+      [result, source, cacheStatus] = await this.getDataForBuildStep();
+    } else if (cachedData) {
+      [result, source, cacheStatus] = this.getDataFromCache(cachedData);
+    } else {
+      [result, source, cacheStatus] = await this.getDataWithFallbacks();
+    }
+    const readMs = Date.now() - startTime;
+    this.trackRead(startTime, cacheHadDefinitions, isFirstRead, source);
+    return Object.assign(result, {
+      metrics: {
+        readMs,
+        source,
+        cacheStatus,
+        connectionState: this.isStreamConnected ? "connected" : "disconnected"
+      }
+    });
+  }
+  /**
+   * Shuts down the data source and releases resources.
+   */
+  async shutdown() {
+    this.stopStream();
+    this.stopPolling();
+    this.data = this.options.datafile;
+    this.isStreamConnected = false;
+    this.hasWarnedAboutStaleData = false;
+    await this.usageTracker.flush();
+  }
+  /**
+   * Returns the datafile with metrics.
+   *
+   * During builds this will read from the bundled file if available.
+   *
+   * This method never opens a streaming connection, but will read from
+   * the stream if it is already open. Otherwise it fetches over the network.
+   */
+  async getDatafile() {
+    const startTime = Date.now();
+    let result;
+    let source;
+    let cacheStatus;
+    if (this.options.buildStep) {
+      [result, source, cacheStatus] = await this.getDataForBuildStep();
+    } else if (this.isStreamConnected && this.data) {
+      [result, source, cacheStatus] = this.getDataFromCache();
+    } else {
+      const fetched = await fetchDatafile(
+        this.host,
+        this.options.sdkKey,
+        this.options.fetch
+      );
+      if (this.isNewerData(fetched)) {
+        this.data = fetched;
+      }
+      [result, source, cacheStatus] = [this.data ?? fetched, "remote", "MISS"];
+    }
+    return Object.assign(result, {
+      metrics: {
+        readMs: Date.now() - startTime,
+        source,
+        cacheStatus,
+        connectionState: this.isStreamConnected ? "connected" : "disconnected"
+      }
+    });
+  }
+  /**
+   * Returns the bundled fallback datafile.
+   */
+  async getFallbackDatafile() {
+    if (!this.bundledDefinitionsPromise) {
+      throw new FallbackNotFoundError();
+    }
+    const bundledResult = await this.bundledDefinitionsPromise;
+    if (!bundledResult) {
+      throw new FallbackNotFoundError();
+    }
+    switch (bundledResult.state) {
+      case "ok":
+        return bundledResult.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(bundledResult.error)
+        );
+    }
+  }
+  // ---------------------------------------------------------------------------
+  // Stream management
+  // ---------------------------------------------------------------------------
+  /**
+   * Attempts to initialize via stream with timeout.
+   * Returns true if stream connected successfully within timeout.
+   */
+  async tryInitializeStream() {
+    let streamPromise;
+    if (this.options.stream.initTimeoutMs <= 0) {
+      try {
+        streamPromise = this.startStream();
+        await streamPromise;
+        return true;
+      } catch {
+        return false;
+      }
+    }
+    let timeoutId;
+    const timeoutPromise = new Promise((resolve) => {
+      timeoutId = setTimeout(
+        () => resolve("timeout"),
+        this.options.stream.initTimeoutMs
+      );
+    });
+    try {
+      streamPromise = this.startStream();
+      const result = await Promise.race([streamPromise, timeoutPromise]);
+      clearTimeout(timeoutId);
+      if (result === "timeout") {
+        console.warn(
+          "@vercel/flags-core: Stream initialization timeout, falling back"
+        );
+        return false;
+      }
+      return true;
+    } catch {
+      clearTimeout(timeoutId);
+      return false;
+    }
+  }
+  /**
+   * Starts the stream connection with callbacks for data and disconnect.
+   */
+  startStream() {
+    if (this.streamPromise) return this.streamPromise;
+    this.streamAbortController = new AbortController();
+    this.isStreamConnected = false;
+    this.hasWarnedAboutStaleData = false;
+    try {
+      const streamPromise = connectStream(
+        {
+          host: this.host,
+          sdkKey: this.options.sdkKey,
+          abortController: this.streamAbortController,
+          fetch: this.options.fetch
+        },
+        {
+          onMessage: (newData) => {
+            if (this.isNewerData(newData)) {
+              this.data = newData;
+            }
+            this.isStreamConnected = true;
+            this.hasWarnedAboutStaleData = false;
+            if (this.pollingIntervalId) {
+              this.stopPolling();
+            }
+          },
+          onDisconnect: () => {
+            this.isStreamConnected = false;
+            if (this.options.polling.enabled && !this.pollingIntervalId) {
+              this.startPolling();
+            }
+          }
+        }
+      );
+      this.streamPromise = streamPromise;
+      return streamPromise;
+    } catch (error) {
+      this.streamPromise = void 0;
+      this.streamAbortController = void 0;
+      throw error;
+    }
+  }
+  /**
+   * Stops the stream connection.
+   */
+  stopStream() {
+    this.streamAbortController?.abort();
+    this.streamAbortController = void 0;
+    this.streamPromise = void 0;
+  }
+  // ---------------------------------------------------------------------------
+  // Polling management
+  // ---------------------------------------------------------------------------
+  /**
+   * Attempts to initialize via polling with timeout.
+   * Returns true if first poll succeeded within timeout.
+   */
+  async tryInitializePolling() {
+    this.pollingAbortController = new AbortController();
+    const pollPromise = this.performPoll();
+    if (this.options.polling.initTimeoutMs <= 0) {
+      try {
+        await pollPromise;
+        if (this.data) {
+          this.startPollingInterval();
+          return true;
+        }
+        return false;
+      } catch {
+        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.startPollingInterval();
+        return true;
+      }
+      return false;
+    } catch {
+      clearTimeout(timeoutId);
+      return false;
+    }
+  }
+  /**
+   * Starts polling (initial poll + interval).
+   */
+  startPolling() {
+    if (this.pollingIntervalId) return;
+    this.pollingAbortController = new AbortController();
+    void this.performPoll();
+    this.startPollingInterval();
+  }
+  /**
+   * Starts the polling interval (without initial poll).
+   */
+  startPollingInterval() {
+    if (this.pollingIntervalId) return;
+    this.pollingIntervalId = setInterval(
+      () => void this.performPoll(),
+      this.options.polling.intervalMs
+    );
+  }
+  /**
+   * Stops polling.
+   */
+  stopPolling() {
+    if (this.pollingIntervalId) {
+      clearInterval(this.pollingIntervalId);
+      this.pollingIntervalId = void 0;
+    }
+    this.pollingAbortController?.abort();
+    this.pollingAbortController = void 0;
+  }
+  /**
+   * Performs a single poll request.
+   */
+  async performPoll() {
+    if (this.pollingAbortController?.signal.aborted) return;
+    try {
+      const data = await fetchDatafile(
+        this.host,
+        this.options.sdkKey,
+        this.options.fetch
+      );
+      if (this.isNewerData(data)) {
+        this.data = data;
+      }
+    } catch (error) {
+      console.error("@vercel/flags-core: Poll failed:", error);
+    }
+  }
+  // ---------------------------------------------------------------------------
+  // Background updates
+  // ---------------------------------------------------------------------------
+  /**
+   * Starts background updates (stream or polling) without blocking.
+   * Used when we already have data from provided datafile.
+   */
+  startBackgroundUpdates() {
+    if (this.options.stream.enabled) {
+      void this.startStream();
+    } else if (this.options.polling.enabled) {
+      this.startPolling();
+    }
+  }
+  // ---------------------------------------------------------------------------
+  // Build step helpers
+  // ---------------------------------------------------------------------------
+  /**
+   * Initializes data for build step environments.
+   */
+  async initializeForBuildStep() {
+    if (this.data) return;
+    if (this.bundledDefinitionsPromise) {
+      const bundledResult = await this.bundledDefinitionsPromise;
+      if (bundledResult?.state === "ok" && bundledResult.definitions) {
+        this.data = bundledResult.definitions;
+        return;
+      }
+    }
+    this.data = await fetchDatafile(
+      this.host,
+      this.options.sdkKey,
+      this.options.fetch
+    );
+  }
+  /**
+   * Retrieves data during build steps.
+   */
+  async getDataForBuildStep() {
+    if (this.data) {
+      return [this.data, "in-memory", "HIT"];
+    }
+    if (this.bundledDefinitionsPromise) {
+      const bundledResult = await this.bundledDefinitionsPromise;
+      if (bundledResult?.state === "ok" && bundledResult.definitions) {
+        this.data = bundledResult.definitions;
+        return [this.data, "embedded", "MISS"];
+      }
+    }
+    this.data = await fetchDatafile(
+      this.host,
+      this.options.sdkKey,
+      this.options.fetch
+    );
+    return [this.data, "remote", "MISS"];
+  }
+  // ---------------------------------------------------------------------------
+  // Runtime helpers
+  // ---------------------------------------------------------------------------
+  /**
+   * Returns data from the in-memory cache.
+   */
+  getDataFromCache(cachedData) {
+    const data = cachedData ?? this.data;
+    this.warnIfDisconnected();
+    const cacheStatus = this.isStreamConnected ? "HIT" : "STALE";
+    return [data, "in-memory", cacheStatus];
+  }
+  /**
+   * Retrieves data using the fallback chain.
+   */
+  async getDataWithFallbacks() {
+    if (this.options.stream.enabled) {
+      const streamSuccess = await this.tryInitializeStream();
+      if (streamSuccess && this.data) {
+        return [this.data, "in-memory", "MISS"];
+      }
+    }
+    if (this.options.polling.enabled) {
+      const pollingSuccess = await this.tryInitializePolling();
+      if (pollingSuccess && this.data) {
+        return [this.data, "remote", "MISS"];
+      }
+    }
+    if (this.options.datafile) {
+      this.data = this.options.datafile;
+      return [this.data, "in-memory", "STALE"];
+    }
+    if (this.bundledDefinitionsPromise) {
+      const bundledResult = await this.bundledDefinitionsPromise;
+      if (bundledResult?.state === "ok" && bundledResult.definitions) {
+        console.warn(
+          "@vercel/flags-core: Using bundled definitions as fallback"
+        );
+        this.data = bundledResult.definitions;
+        return [this.data, "embedded", "STALE"];
+      }
+    }
+    throw new Error(
+      "@vercel/flags-core: No flag definitions available. Ensure streaming/polling is enabled or provide a datafile."
+    );
+  }
+  /**
+   * Initializes from bundled definitions.
+   */
+  async initializeFromBundled() {
+    if (!this.bundledDefinitionsPromise) {
+      throw new Error(
+        "@vercel/flags-core: No flag definitions available. Ensure streaming/polling is enabled or provide a datafile."
+      );
+    }
+    const bundledResult = await this.bundledDefinitionsPromise;
+    if (bundledResult?.state === "ok" && bundledResult.definitions) {
+      this.data = bundledResult.definitions;
+      return;
+    }
+    throw new Error(
+      "@vercel/flags-core: No flag definitions available. Bundled definitions not found."
+    );
+  }
+  /**
+   * Parses a configUpdatedAt value (number or string) into a numeric timestamp.
+   * Returns undefined if the value is missing or cannot be parsed.
+   */
+  static 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;
+  }
+  /**
+   * 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 older.
+   */
+  isNewerData(incoming) {
+    if (!this.data) return true;
+    const currentTs = _FlagNetworkDataSource.parseConfigUpdatedAt(
+      this.data.configUpdatedAt
+    );
+    const incomingTs = _FlagNetworkDataSource.parseConfigUpdatedAt(
+      incoming.configUpdatedAt
+    );
+    if (currentTs === void 0 || incomingTs === void 0) {
+      return true;
+    }
+    return incomingTs >= currentTs;
+  }
+  /**
+   * Logs a warning if returning cached data while stream is disconnected.
+   */
+  warnIfDisconnected() {
+    if (!this.isStreamConnected && !this.hasWarnedAboutStaleData) {
+      this.hasWarnedAboutStaleData = true;
+      console.warn(
+        "@vercel/flags-core: Returning in-memory flag definitions while stream is disconnected. Data may be stale."
+      );
+    }
+  }
+  // ---------------------------------------------------------------------------
+  // Usage tracking
+  // ---------------------------------------------------------------------------
+  /**
+   * Tracks a read operation for usage analytics.
+   */
+  trackRead(startTime, cacheHadDefinitions, isFirstRead, source) {
+    const configOrigin = source === "embedded" ? "embedded" : "in-memory";
+    const trackOptions = {
+      configOrigin,
+      cacheStatus: cacheHadDefinitions ? "HIT" : "MISS",
+      cacheIsBlocking: !cacheHadDefinitions,
+      duration: Date.now() - startTime
+    };
+    const configUpdatedAt = this.data?.configUpdatedAt;
+    if (typeof configUpdatedAt === "number") {
+      trackOptions.configUpdatedAt = configUpdatedAt;
+    }
+    if (isFirstRead) {
+      trackOptions.cacheIsFirstRead = true;
+    }
+    this.usageTracker.trackRead(trackOptions);
+  }
+};
+
+// 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 {
+  }
+  return null;
+}
+
+// src/index.make.ts
+function make(createRawClient) {
+  let _defaultFlagsClient = null;
+  function createClient2(sdkKeyOrConnectionString, options) {
+    if (!sdkKeyOrConnectionString) throw new Error("flags: Missing sdkKey");
+    const sdkKey = parseSdkKeyFromFlagsConnectionString(
+      sdkKeyOrConnectionString
+    );
+    if (!sdkKey) {
+      throw new Error("flags: Missing sdkKey in connection string");
+    }
+    const dataSource = new FlagNetworkDataSource({ sdkKey, ...options });
+    return createRawClient({
+      dataSource,
+      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("flags: Missing sdkKey");
+        }
+        _defaultFlagsClient = createClient2(sdkKey);
+      }
+      return _defaultFlagsClient[prop];
+    }
+  });
+  return {
+    flagsClient: flagsClient2,
+    resetDefaultFlagsClient: resetDefaultFlagsClient2,
+    createClient: createClient2
+  };
+}
+
+// src/index.default.ts
+var {
+  /**
+   * A lazily-initialized default flags client.
+   *
+   * - relies on process.env.FLAGS
+   * - does not use process.env.EDGE_CONFIG
+   */
+  flagsClient,
+  /**
+   * For testing purposes
+   */
+  resetDefaultFlagsClient,
+  /**
+   * Create a flags client based on an SDK Key
+   */
+  createClient
+} = make(createCreateRawClient(client_fns_exports));
+
+export {
+  ResolutionReason,
+  evaluate,
+  FallbackNotFoundError,
+  FallbackEntryNotFoundError,
+  FlagNetworkDataSource,
+  flagsClient,
+  resetDefaultFlagsClient,
+  createClient
+};
+//# sourceMappingURL=chunk-7BUTND2Q.js.map