@quonfig/node 0.0.1

package/dist/index.cjs

@@ -0,0 +1,1912 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  BoundQuonfig: () => BoundQuonfig,
+  Client: () => Client,
+  ConfigStore: () => ConfigStore,
+  ConfigType: () => ConfigType,
+  ConfigValueType: () => ConfigValueType,
+  ContextShapeCollector: () => ContextShapeCollector,
+  EvaluationSummaryCollector: () => EvaluationSummaryCollector,
+  Evaluator: () => Evaluator,
+  ExampleContextCollector: () => ExampleContextCollector,
+  LOG_LEVEL_PREFIX: () => LOG_LEVEL_PREFIX,
+  OP_ALWAYS_TRUE: () => OP_ALWAYS_TRUE,
+  OP_HIERARCHICAL_MATCH: () => OP_HIERARCHICAL_MATCH,
+  OP_IN_INT_RANGE: () => OP_IN_INT_RANGE,
+  OP_IN_SEG: () => OP_IN_SEG,
+  OP_NOT_IN_SEG: () => OP_NOT_IN_SEG,
+  OP_NOT_SET: () => OP_NOT_SET,
+  OP_PROP_AFTER: () => OP_PROP_AFTER,
+  OP_PROP_BEFORE: () => OP_PROP_BEFORE,
+  OP_PROP_CONTAINS_ONE_OF: () => OP_PROP_CONTAINS_ONE_OF,
+  OP_PROP_DOES_NOT_CONTAIN_ONE_OF: () => OP_PROP_DOES_NOT_CONTAIN_ONE_OF,
+  OP_PROP_DOES_NOT_END_WITH_ONE_OF: () => OP_PROP_DOES_NOT_END_WITH_ONE_OF,
+  OP_PROP_DOES_NOT_MATCH: () => OP_PROP_DOES_NOT_MATCH,
+  OP_PROP_DOES_NOT_START_WITH_ONE_OF: () => OP_PROP_DOES_NOT_START_WITH_ONE_OF,
+  OP_PROP_ENDS_WITH_ONE_OF: () => OP_PROP_ENDS_WITH_ONE_OF,
+  OP_PROP_GREATER_THAN: () => OP_PROP_GREATER_THAN,
+  OP_PROP_GREATER_THAN_OR_EQUAL: () => OP_PROP_GREATER_THAN_OR_EQUAL,
+  OP_PROP_IS_NOT_ONE_OF: () => OP_PROP_IS_NOT_ONE_OF,
+  OP_PROP_IS_ONE_OF: () => OP_PROP_IS_ONE_OF,
+  OP_PROP_LESS_THAN: () => OP_PROP_LESS_THAN,
+  OP_PROP_LESS_THAN_OR_EQUAL: () => OP_PROP_LESS_THAN_OR_EQUAL,
+  OP_PROP_MATCHES: () => OP_PROP_MATCHES,
+  OP_PROP_SEMVER_EQUAL: () => OP_PROP_SEMVER_EQUAL,
+  OP_PROP_SEMVER_GREATER_THAN: () => OP_PROP_SEMVER_GREATER_THAN,
+  OP_PROP_SEMVER_LESS_THAN: () => OP_PROP_SEMVER_LESS_THAN,
+  OP_PROP_STARTS_WITH_ONE_OF: () => OP_PROP_STARTS_WITH_ONE_OF,
+  ProvidedSource: () => ProvidedSource,
+  Quonfig: () => Quonfig,
+  Resolver: () => Resolver,
+  TelemetryReporter: () => TelemetryReporter,
+  Transport: () => Transport,
+  WeightedValueResolver: () => WeightedValueResolver,
+  compareSemver: () => compareSemver,
+  contextLookup: () => contextLookup,
+  decrypt: () => decrypt,
+  durationToMilliseconds: () => durationToMilliseconds,
+  encrypt: () => encrypt,
+  encryption: () => encryption,
+  evaluateCriterion: () => evaluateCriterion,
+  generateNewHexKey: () => generateNewHexKey,
+  getContextValue: () => getContextValue,
+  getProjectEnvFromSdkKey: () => getProjectEnvFromSdkKey,
+  hashZeroToOne: () => hashZeroToOne,
+  mergeContexts: () => mergeContexts,
+  parseLevel: () => parseLevel,
+  parseSemver: () => parseSemver,
+  shouldLog: () => shouldLog,
+  valueTypeStringForConfig: () => valueTypeStringForConfig,
+  wordLevelToNumber: () => wordLevelToNumber
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/quonfig.ts
+var import_crypto3 = require("crypto");
+var import_fs = require("fs");
+
+// src/store.ts
+var ConfigStore = class {
+  configs = /* @__PURE__ */ new Map();
+  version = "";
+  environmentId = "";
+  get(key) {
+    return this.configs.get(key);
+  }
+  keys() {
+    return Array.from(this.configs.keys());
+  }
+  getEnvironmentId() {
+    return this.environmentId;
+  }
+  getVersion() {
+    return this.version;
+  }
+  /**
+   * Replace all configs with those from the given envelope.
+   * Also normalizes values that need special deserialization (weighted_values, provided).
+   */
+  update(envelope) {
+    const next = /* @__PURE__ */ new Map();
+    for (const cfg of envelope.configs) {
+      normalizeConfigResponse(cfg);
+      next.set(cfg.key, cfg);
+    }
+    this.configs = next;
+    this.version = envelope.meta.version;
+    this.environmentId = envelope.meta.environment;
+  }
+  /**
+   * Load from a raw datafile (JSON object).
+   */
+  loadFromDatafile(data) {
+    this.update(data);
+  }
+};
+function normalizeConfigResponse(cfg) {
+  if (!cfg.default.rules) {
+    cfg.default.rules = [];
+  }
+  for (const rule of cfg.default.rules) {
+    normalizeValue(rule.value);
+    for (const criterion of rule.criteria ?? []) {
+      if (criterion.valueToMatch) {
+        normalizeValue(criterion.valueToMatch);
+      }
+    }
+  }
+  if (cfg.environment) {
+    if (!cfg.environment.rules) {
+      cfg.environment.rules = [];
+    }
+    for (const rule of cfg.environment.rules) {
+      normalizeValue(rule.value);
+      for (const criterion of rule.criteria ?? []) {
+        if (criterion.valueToMatch) {
+          normalizeValue(criterion.valueToMatch);
+        }
+      }
+    }
+  }
+}
+function normalizeValue(v) {
+  if (v.type === "weighted_values" && v.value && typeof v.value === "object") {
+    const wvd = v.value;
+    if (wvd.weightedValues) {
+      for (const wv of wvd.weightedValues) {
+        if (wv.value) {
+          normalizeValue(wv.value);
+        }
+      }
+    }
+  }
+  if (v.type === "provided" && v.value && typeof v.value === "object") {
+    const pd = v.value;
+    if (!pd.source) {
+      pd.source = "ENV_VAR";
+    }
+  }
+}
+
+// src/context.ts
+function contextLookup(contexts, propertyName) {
+  if (propertyName === void 0) {
+    return void 0;
+  }
+  const dotIndex = propertyName.indexOf(".");
+  if (dotIndex === -1) {
+    const ctx2 = contexts[""];
+    if (ctx2 === void 0) {
+      return void 0;
+    }
+    return ctx2[propertyName];
+  }
+  const contextName = propertyName.slice(0, dotIndex);
+  const key = propertyName.slice(dotIndex + 1);
+  const ctx = contexts[contextName];
+  if (ctx === void 0) {
+    return void 0;
+  }
+  return ctx[key];
+}
+function mergeContexts(...sets) {
+  const result = {};
+  for (const cs of sets) {
+    if (cs === void 0) {
+      continue;
+    }
+    for (const [name, ctx] of Object.entries(cs)) {
+      if (result[name] === void 0) {
+        result[name] = { ...ctx };
+      } else {
+        result[name] = { ...result[name], ...ctx };
+      }
+    }
+  }
+  return result;
+}
+function getContextValue(contexts, propertyName) {
+  if (propertyName === "prefab.current-time" || propertyName === "quonfig.current-time" || propertyName === "reforge.current-time") {
+    return { value: Date.now(), exists: true };
+  }
+  const value = contextLookup(contexts, propertyName);
+  return { value, exists: value !== void 0 && value !== null };
+}
+
+// src/semver.ts
+var SEMVER_PATTERN = /^(?<major>0|[1-9]\d*)\.(?<minor>0|[1-9]\d*)\.(?<patch>0|[1-9]\d*)(?:-(?<prerelease>(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\.(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?(?:\+(?<buildmetadata>[0-9a-zA-Z-]+(?:\.[0-9a-zA-Z-]+)*))?$/;
+function parseSemver(version) {
+  if (!version) {
+    return void 0;
+  }
+  const match = SEMVER_PATTERN.exec(version);
+  if (!match || !match.groups) {
+    return void 0;
+  }
+  const major = parseInt(match.groups["major"], 10);
+  const minor = parseInt(match.groups["minor"], 10);
+  const patch = parseInt(match.groups["patch"], 10);
+  if (isNaN(major) || isNaN(minor) || isNaN(patch)) {
+    return void 0;
+  }
+  return {
+    major,
+    minor,
+    patch,
+    prerelease: match.groups["prerelease"] ?? "",
+    buildMetadata: match.groups["buildmetadata"] ?? ""
+  };
+}
+function isNumeric(s) {
+  return /^\d+$/.test(s);
+}
+function comparePreReleaseIdentifiers(id1, id2) {
+  if (isNumeric(id1) && isNumeric(id2)) {
+    const num1 = parseInt(id1, 10);
+    const num2 = parseInt(id2, 10);
+    if (num1 < num2) return -1;
+    if (num1 > num2) return 1;
+    return 0;
+  }
+  if (isNumeric(id1)) return -1;
+  if (isNumeric(id2)) return 1;
+  if (id1 < id2) return -1;
+  if (id1 > id2) return 1;
+  return 0;
+}
+function comparePreRelease(pre1, pre2) {
+  if (pre1 === "" && pre2 === "") return 0;
+  if (pre1 === "") return 1;
+  if (pre2 === "") return -1;
+  const ids1 = pre1.split(".");
+  const ids2 = pre2.split(".");
+  const minLen = Math.min(ids1.length, ids2.length);
+  for (let i = 0; i < minLen; i++) {
+    const cmp = comparePreReleaseIdentifiers(ids1[i], ids2[i]);
+    if (cmp !== 0) return cmp;
+  }
+  if (ids1.length < ids2.length) return -1;
+  if (ids1.length > ids2.length) return 1;
+  return 0;
+}
+function compareSemver(a, b) {
+  if (a.major !== b.major) return a.major > b.major ? 1 : -1;
+  if (a.minor !== b.minor) return a.minor > b.minor ? 1 : -1;
+  if (a.patch !== b.patch) return a.patch > b.patch ? 1 : -1;
+  return comparePreRelease(a.prerelease, b.prerelease);
+}
+
+// src/operators.ts
+var OP_NOT_SET = "NOT_SET";
+var OP_ALWAYS_TRUE = "ALWAYS_TRUE";
+var OP_PROP_IS_ONE_OF = "PROP_IS_ONE_OF";
+var OP_PROP_IS_NOT_ONE_OF = "PROP_IS_NOT_ONE_OF";
+var OP_PROP_STARTS_WITH_ONE_OF = "PROP_STARTS_WITH_ONE_OF";
+var OP_PROP_DOES_NOT_START_WITH_ONE_OF = "PROP_DOES_NOT_START_WITH_ONE_OF";
+var OP_PROP_ENDS_WITH_ONE_OF = "PROP_ENDS_WITH_ONE_OF";
+var OP_PROP_DOES_NOT_END_WITH_ONE_OF = "PROP_DOES_NOT_END_WITH_ONE_OF";
+var OP_PROP_CONTAINS_ONE_OF = "PROP_CONTAINS_ONE_OF";
+var OP_PROP_DOES_NOT_CONTAIN_ONE_OF = "PROP_DOES_NOT_CONTAIN_ONE_OF";
+var OP_PROP_MATCHES = "PROP_MATCHES";
+var OP_PROP_DOES_NOT_MATCH = "PROP_DOES_NOT_MATCH";
+var OP_HIERARCHICAL_MATCH = "HIERARCHICAL_MATCH";
+var OP_IN_INT_RANGE = "IN_INT_RANGE";
+var OP_PROP_GREATER_THAN = "PROP_GREATER_THAN";
+var OP_PROP_GREATER_THAN_OR_EQUAL = "PROP_GREATER_THAN_OR_EQUAL";
+var OP_PROP_LESS_THAN = "PROP_LESS_THAN";
+var OP_PROP_LESS_THAN_OR_EQUAL = "PROP_LESS_THAN_OR_EQUAL";
+var OP_PROP_BEFORE = "PROP_BEFORE";
+var OP_PROP_AFTER = "PROP_AFTER";
+var OP_PROP_SEMVER_LESS_THAN = "PROP_SEMVER_LESS_THAN";
+var OP_PROP_SEMVER_EQUAL = "PROP_SEMVER_EQUAL";
+var OP_PROP_SEMVER_GREATER_THAN = "PROP_SEMVER_GREATER_THAN";
+var OP_IN_SEG = "IN_SEG";
+var OP_NOT_IN_SEG = "NOT_IN_SEG";
+function toString(v) {
+  if (v === null || v === void 0) return "";
+  return String(v);
+}
+function toStringSlice(v) {
+  if (v === null || v === void 0) return [];
+  if (Array.isArray(v)) {
+    return v.map((item) => toString(item));
+  }
+  return [toString(v)];
+}
+function getStringList(v) {
+  if (v === void 0 || v === null) return void 0;
+  if (Array.isArray(v.value)) {
+    return v.value.map((item) => toString(item));
+  }
+  return void 0;
+}
+function isString(v) {
+  return typeof v === "string";
+}
+function isNumber(v) {
+  return typeof v === "number";
+}
+function isNumericValue(v) {
+  if (typeof v === "number") return true;
+  if (typeof v === "string") return !isNaN(Number(v)) && v.trim() !== "";
+  return false;
+}
+function toFloat64(v) {
+  if (typeof v === "number") return v;
+  if (typeof v === "string") {
+    const n = Number(v);
+    if (!isNaN(n)) return n;
+  }
+  return void 0;
+}
+function compareNumbers(a, b) {
+  const af = toFloat64(a);
+  const bf = toFloat64(b);
+  if (af === void 0 || bf === void 0) return void 0;
+  if (af < bf) return -1;
+  if (af > bf) return 1;
+  return 0;
+}
+function dateToMillis(val) {
+  if (typeof val === "number") return val;
+  if (typeof val === "string") {
+    const d = Date.parse(val);
+    if (!isNaN(d)) return d;
+    const n = parseInt(val, 10);
+    if (!isNaN(n)) return n;
+  }
+  return void 0;
+}
+function stringInSlice(s, list) {
+  return list.includes(s);
+}
+function startsWithAny(prefixes, target) {
+  return prefixes.some((p) => target.startsWith(p));
+}
+function endsWithAny(suffixes, target) {
+  return suffixes.some((s) => target.endsWith(s));
+}
+function containsAny(substrings, target) {
+  return substrings.some((s) => target.includes(s));
+}
+function extractIntRange(v) {
+  let start = Number.MIN_SAFE_INTEGER;
+  let end = Number.MAX_SAFE_INTEGER;
+  if (v === void 0 || v === null) return { start, end };
+  if (typeof v.value === "object" && v.value !== null && !Array.isArray(v.value)) {
+    if ("start" in v.value) {
+      const s = toFloat64(v.value.start);
+      if (s !== void 0) start = s;
+    }
+    if ("end" in v.value) {
+      const e = toFloat64(v.value.end);
+      if (e !== void 0) end = e;
+    }
+  }
+  return { start, end };
+}
+function evaluateCriterion(contextValue, contextExists, criterion, segmentResolver) {
+  const matchValue = criterion.valueToMatch;
+  switch (criterion.operator) {
+    case OP_NOT_SET:
+      return false;
+    case OP_ALWAYS_TRUE:
+      return true;
+    case OP_PROP_IS_ONE_OF:
+    case OP_PROP_IS_NOT_ONE_OF: {
+      if (contextExists && matchValue !== void 0) {
+        const matchStrings = getStringList(matchValue);
+        if (matchStrings !== void 0) {
+          const contextStrings = toStringSlice(contextValue);
+          let matchFound = false;
+          for (const cv of contextStrings) {
+            if (stringInSlice(cv, matchStrings)) {
+              matchFound = true;
+              break;
+            }
+          }
+          return matchFound === (criterion.operator === OP_PROP_IS_ONE_OF);
+        }
+      }
+      return criterion.operator === OP_PROP_IS_NOT_ONE_OF;
+    }
+    case OP_PROP_STARTS_WITH_ONE_OF:
+    case OP_PROP_DOES_NOT_START_WITH_ONE_OF: {
+      if (contextExists && matchValue !== void 0) {
+        const matchStrings = getStringList(matchValue);
+        if (matchStrings !== void 0) {
+          const cv = toString(contextValue);
+          const matchFound = startsWithAny(matchStrings, cv);
+          return matchFound === (criterion.operator === OP_PROP_STARTS_WITH_ONE_OF);
+        }
+      }
+      return criterion.operator === OP_PROP_DOES_NOT_START_WITH_ONE_OF;
+    }
+    case OP_PROP_ENDS_WITH_ONE_OF:
+    case OP_PROP_DOES_NOT_END_WITH_ONE_OF: {
+      if (contextExists && matchValue !== void 0) {
+        const matchStrings = getStringList(matchValue);
+        if (matchStrings !== void 0) {
+          const cv = toString(contextValue);
+          const matchFound = endsWithAny(matchStrings, cv);
+          return matchFound === (criterion.operator === OP_PROP_ENDS_WITH_ONE_OF);
+        }
+      }
+      return criterion.operator === OP_PROP_DOES_NOT_END_WITH_ONE_OF;
+    }
+    case OP_PROP_CONTAINS_ONE_OF:
+    case OP_PROP_DOES_NOT_CONTAIN_ONE_OF: {
+      if (contextExists && matchValue !== void 0) {
+        const matchStrings = getStringList(matchValue);
+        if (matchStrings !== void 0) {
+          const cv = toString(contextValue);
+          const matchFound = containsAny(matchStrings, cv);
+          return matchFound === (criterion.operator === OP_PROP_CONTAINS_ONE_OF);
+        }
+      }
+      return criterion.operator === OP_PROP_DOES_NOT_CONTAIN_ONE_OF;
+    }
+    case OP_PROP_MATCHES:
+    case OP_PROP_DOES_NOT_MATCH: {
+      if (contextExists && matchValue !== void 0 && isString(contextValue) && isString(matchValue.value)) {
+        try {
+          const re = new RegExp(matchValue.value);
+          const matched = re.test(contextValue);
+          return matched === (criterion.operator === OP_PROP_MATCHES);
+        } catch {
+        }
+      }
+      return false;
+    }
+    case OP_HIERARCHICAL_MATCH: {
+      if (contextExists && matchValue !== void 0) {
+        const cv = toString(contextValue);
+        const mv = toString(matchValue.value);
+        return cv.startsWith(mv);
+      }
+      return false;
+    }
+    case OP_IN_INT_RANGE: {
+      if (contextExists && matchValue !== void 0) {
+        const { start, end } = extractIntRange(matchValue);
+        const numVal = toFloat64(contextValue);
+        if (numVal !== void 0) {
+          return numVal >= start && numVal < end;
+        }
+      }
+      return false;
+    }
+    case OP_PROP_GREATER_THAN:
+    case OP_PROP_GREATER_THAN_OR_EQUAL:
+    case OP_PROP_LESS_THAN:
+    case OP_PROP_LESS_THAN_OR_EQUAL: {
+      if (contextExists && matchValue !== void 0 && isNumber(contextValue) && isNumericValue(matchValue.value)) {
+        const cmp = compareNumbers(contextValue, matchValue.value);
+        if (cmp !== void 0) {
+          switch (criterion.operator) {
+            case OP_PROP_GREATER_THAN:
+              return cmp > 0;
+            case OP_PROP_GREATER_THAN_OR_EQUAL:
+              return cmp >= 0;
+            case OP_PROP_LESS_THAN:
+              return cmp < 0;
+            case OP_PROP_LESS_THAN_OR_EQUAL:
+              return cmp <= 0;
+          }
+        }
+      }
+      return false;
+    }
+    case OP_PROP_BEFORE:
+    case OP_PROP_AFTER: {
+      if (contextExists && matchValue !== void 0) {
+        const contextMillis = dateToMillis(contextValue);
+        const matchMillis = dateToMillis(matchValue.value);
+        if (contextMillis !== void 0 && matchMillis !== void 0) {
+          if (criterion.operator === OP_PROP_BEFORE) {
+            return contextMillis < matchMillis;
+          }
+          return contextMillis > matchMillis;
+        }
+      }
+      return false;
+    }
+    case OP_PROP_SEMVER_LESS_THAN:
+    case OP_PROP_SEMVER_EQUAL:
+    case OP_PROP_SEMVER_GREATER_THAN: {
+      if (contextExists && matchValue !== void 0 && isString(contextValue) && isString(matchValue.value)) {
+        const svContext = parseSemver(contextValue);
+        const svMatch = parseSemver(matchValue.value);
+        if (svContext !== void 0 && svMatch !== void 0) {
+          const cmp = compareSemver(svContext, svMatch);
+          switch (criterion.operator) {
+            case OP_PROP_SEMVER_LESS_THAN:
+              return cmp < 0;
+            case OP_PROP_SEMVER_EQUAL:
+              return cmp === 0;
+            case OP_PROP_SEMVER_GREATER_THAN:
+              return cmp > 0;
+          }
+        }
+      }
+      return false;
+    }
+    case OP_IN_SEG:
+    case OP_NOT_IN_SEG: {
+      if (matchValue !== void 0 && segmentResolver !== void 0) {
+        const segmentKey = toString(matchValue.value);
+        const { result, found } = segmentResolver(segmentKey);
+        if (!found) {
+          return criterion.operator === OP_NOT_IN_SEG;
+        }
+        return result === (criterion.operator === OP_IN_SEG);
+      }
+      return criterion.operator === OP_NOT_IN_SEG;
+    }
+    default:
+      return false;
+  }
+}
+
+// src/hashing.ts
+var import_murmurhash = __toESM(require("murmurhash"), 1);
+function hashZeroToOne(value) {
+  const hash = import_murmurhash.default.v3(value);
+  return hash / 4294967295;
+}
+
+// src/weighted.ts
+var WeightedValueResolver = class {
+  /**
+   * Resolve picks a value from the weighted distribution.
+   *
+   * If hashByPropertyName is set and the context has a value for that property,
+   * the selection is deterministic via Murmur3 hash. Otherwise, it falls back
+   * to Math.random().
+   *
+   * Returns the selected value and its index, or [undefined, -1] if no values.
+   */
+  resolve(wv, configKey, contexts) {
+    const fraction = this.getUserFraction(wv, configKey, contexts);
+    let totalWeight = 0;
+    for (const entry of wv.weightedValues) {
+      totalWeight += entry.weight;
+    }
+    const threshold = fraction * totalWeight;
+    let runningSum = 0;
+    for (let i = 0; i < wv.weightedValues.length; i++) {
+      runningSum += wv.weightedValues[i].weight;
+      if (runningSum >= threshold) {
+        return { value: { ...wv.weightedValues[i].value }, index: i };
+      }
+    }
+    if (wv.weightedValues.length > 0) {
+      return { value: { ...wv.weightedValues[0].value }, index: 0 };
+    }
+    return { value: void 0, index: -1 };
+  }
+  getUserFraction(wv, configKey, contexts) {
+    if (wv.hashByPropertyName) {
+      const value = contextLookup(contexts, wv.hashByPropertyName);
+      if (value !== void 0 && value !== null) {
+        const valueToHash = `${configKey}${value}`;
+        return hashZeroToOne(valueToHash);
+      }
+    }
+    return Math.random();
+  }
+};
+
+// src/evaluator.ts
+var Evaluator = class {
+  configStore;
+  weighted;
+  constructor(configStore) {
+    this.configStore = configStore;
+    this.weighted = new WeightedValueResolver();
+  }
+  /**
+   * Evaluate a config for the given environment and context.
+   *
+   * Evaluation flow:
+   *  1. Find the environment block matching envID (if any)
+   *  2. Iterate its rules top-to-bottom; first match wins
+   *  3. If no env-specific match, fall back to default.rules
+   *  4. For each rule, all criteria must match (AND logic)
+   *  5. If matched value is weighted_values, resolve through WeightedValueResolver
+   */
+  evaluateConfig(cfg, envID, contexts) {
+    if (envID && cfg.environment && cfg.environment.id === envID) {
+      const match2 = this.evaluateRules(cfg, cfg.environment.rules ?? [], contexts, 0);
+      if (match2 !== void 0) {
+        return match2;
+      }
+    }
+    const match = this.evaluateRules(cfg, cfg.default.rules ?? [], contexts, 0);
+    if (match !== void 0) {
+      return match;
+    }
+    return { isMatch: false, ruleIndex: -1, weightedValueIndex: -1 };
+  }
+  evaluateRules(cfg, rules, contexts, ruleIndexOffset) {
+    for (let i = 0; i < rules.length; i++) {
+      const rule = rules[i];
+      if (this.evaluateAllCriteria(cfg, rule.criteria, contexts)) {
+        const value = { ...rule.value };
+        const match = {
+          isMatch: true,
+          value,
+          ruleIndex: ruleIndexOffset + i,
+          weightedValueIndex: -1
+        };
+        if (value.type === "weighted_values" && value.value) {
+          const wvData = value.value;
+          if (wvData && wvData.weightedValues) {
+            const resolved = this.weighted.resolve(wvData, cfg.key, contexts);
+            if (resolved.value !== void 0) {
+              match.value = resolved.value;
+              match.weightedValueIndex = resolved.index;
+            }
+          }
+        }
+        return match;
+      }
+    }
+    return void 0;
+  }
+  evaluateAllCriteria(cfg, criteria, contexts) {
+    for (const criterion of criteria) {
+      if (!this.evaluateSingleCriterion(cfg, criterion, contexts)) {
+        return false;
+      }
+    }
+    return true;
+  }
+  evaluateSingleCriterion(cfg, criterion, contexts) {
+    const propertyName = criterion.propertyName ?? "";
+    const { value: contextValue, exists: contextExists } = getContextValue(
+      contexts,
+      propertyName
+    );
+    const segmentResolver = (segmentKey) => {
+      const segConfig = this.configStore.get(segmentKey);
+      if (segConfig === void 0) {
+        return { result: false, found: false };
+      }
+      const segMatch = this.evaluateConfig(segConfig, "", contexts);
+      if (!segMatch.isMatch || segMatch.value === void 0) {
+        return { result: false, found: false };
+      }
+      return { result: !!segMatch.value.value, found: true };
+    };
+    return evaluateCriterion(contextValue, contextExists, criterion, segmentResolver);
+  }
+};
+
+// src/encryption.ts
+var import_crypto = require("crypto");
+var CIPHER_TYPE = "aes-256-gcm";
+var SEPARATOR = "--";
+var KEY_LENGTH = 32;
+function generateNewHexKey() {
+  return (0, import_crypto.randomBytes)(KEY_LENGTH).toString("hex");
+}
+function encrypt(clearText, keyStringHex) {
+  if (keyStringHex.length !== KEY_LENGTH * 2) {
+    throw new Error(
+      `Invalid key length. Key must be a 64 character hex string (representing a 32-byte key). You provided ${keyStringHex.length} characters.`
+    );
+  }
+  const key = Buffer.from(keyStringHex, "hex");
+  const iv = (0, import_crypto.randomBytes)(12);
+  const cipher = (0, import_crypto.createCipheriv)(CIPHER_TYPE, key, iv);
+  let encrypted = cipher.update(clearText, "utf8", "hex");
+  encrypted += cipher.final("hex");
+  const tag = cipher.getAuthTag().toString("hex");
+  return [encrypted, iv.toString("hex"), tag].join(SEPARATOR);
+}
+function decrypt(encryptedString, keyStringHex) {
+  if (keyStringHex.length !== 64) {
+    throw new Error(
+      "Invalid key length. Key must be a 64-character hex string."
+    );
+  }
+  const key = Buffer.from(keyStringHex, "hex");
+  const parts = encryptedString.split(SEPARATOR);
+  if (parts.length !== 3) {
+    throw new Error(
+      "Invalid encrypted string. Must contain encrypted data, IV, and auth tag."
+    );
+  }
+  const encryptedDataPart = parts[0];
+  const ivPart = parts[1];
+  const authTagPart = parts[2];
+  if (encryptedDataPart === "") {
+    return "";
+  }
+  const encryptedData = Buffer.from(encryptedDataPart, "hex");
+  const iv = Buffer.from(ivPart, "hex");
+  const authTag = Buffer.from(authTagPart, "hex");
+  const decipher = (0, import_crypto.createDecipheriv)(CIPHER_TYPE, key, iv);
+  decipher.setAuthTag(authTag);
+  let decrypted = decipher.update(encryptedData);
+  decrypted = Buffer.concat([decrypted, decipher.final()]);
+  return decrypted.toString("utf8");
+}
+
+// src/duration.ts
+var PATTERN = /P(?:(?<days>\d+(?:\.\d+)?)D)?(?:T(?:(?<hours>\d+(?:\.\d+)?)H)?(?:(?<minutes>\d+(?:\.\d+)?)M)?(?:(?<seconds>\d+(?:\.\d+)?)S)?)?/;
+var MINUTES_IN_SECONDS = 60;
+var HOURS_IN_SECONDS = 60 * MINUTES_IN_SECONDS;
+var DAYS_IN_SECONDS = 24 * HOURS_IN_SECONDS;
+function durationToMilliseconds(duration) {
+  const match = PATTERN.exec(duration);
+  if (match === null) {
+    return 0;
+  }
+  const days = parseFloat(match.groups?.["days"] ?? "0");
+  const hours = parseFloat(match.groups?.["hours"] ?? "0");
+  const minutes = parseFloat(match.groups?.["minutes"] ?? "0");
+  const seconds = parseFloat(match.groups?.["seconds"] ?? "0");
+  return (days * DAYS_IN_SECONDS + hours * HOURS_IN_SECONDS + minutes * MINUTES_IN_SECONDS + seconds) * 1e3;
+}
+
+// src/resolver.ts
+var import_crypto2 = require("crypto");
+var TRUE_VALUES = /* @__PURE__ */ new Set(["true", "1", "t", "yes"]);
+var CONFIDENTIAL_PREFIX = "*****";
+function makeConfidential(secret) {
+  const md5 = (0, import_crypto2.createHash)("md5").update(secret).digest("hex");
+  return `${CONFIDENTIAL_PREFIX}${md5.slice(-5)}`;
+}
+var Resolver = class {
+  store;
+  evaluator;
+  constructor(store, evaluator) {
+    this.store = store;
+    this.evaluator = evaluator;
+  }
+  /**
+   * Resolve a matched value. Handles:
+   * - provided values (ENV_VAR lookup)
+   * - decryption of confidential values
+   */
+  resolveValue(val, configKey, valueType, envID, contexts) {
+    if (val.type === "provided") {
+      const provided = val.value;
+      if (provided && provided.source === "ENV_VAR" && provided.lookup) {
+        const envValue = process.env[provided.lookup];
+        if (envValue === void 0) {
+          throw new Error(
+            `Environment variable "${provided.lookup}" not set for config "${configKey}"`
+          );
+        }
+        const coerced = coerceValue(envValue, valueType);
+        return {
+          resolved: {
+            type: valueTypeForCoerced(valueType),
+            value: coerced
+          }
+        };
+      }
+      return { resolved: val };
+    }
+    if (val.confidential && val.decryptWith) {
+      const keyCfg = this.store.get(val.decryptWith);
+      if (keyCfg === void 0) {
+        throw new Error(`Decryption key config "${val.decryptWith}" not found`);
+      }
+      const keyMatch = this.evaluator.evaluateConfig(keyCfg, envID, contexts);
+      if (!keyMatch.isMatch || keyMatch.value === void 0) {
+        throw new Error(`Decryption key config "${val.decryptWith}" did not match`);
+      }
+      const { resolved: resolvedKey } = this.resolveValue(
+        keyMatch.value,
+        keyCfg.key,
+        keyCfg.valueType,
+        envID,
+        contexts
+      );
+      const secretKey = String(resolvedKey.value);
+      if (!secretKey) {
+        throw new Error(`Decryption key from "${val.decryptWith}" is empty`);
+      }
+      const decrypted = decrypt(String(val.value), secretKey);
+      return {
+        resolved: {
+          type: "string",
+          value: decrypted,
+          confidential: true
+        },
+        reportableValue: makeConfidential(String(val.value))
+      };
+    }
+    if (val.confidential) {
+      return {
+        resolved: val,
+        reportableValue: makeConfidential(String(val.value))
+      };
+    }
+    return { resolved: val };
+  }
+  /**
+   * Unwrap a resolved value to a plain JS value.
+   */
+  unwrapValue(val) {
+    switch (val.type) {
+      case "bool":
+        return !!val.value;
+      case "int":
+        return typeof val.value === "number" ? val.value : parseInt(String(val.value), 10);
+      case "double":
+        return typeof val.value === "number" ? val.value : parseFloat(String(val.value));
+      case "string":
+        return String(val.value ?? "");
+      case "json":
+        if (typeof val.value === "string") {
+          try {
+            return JSON.parse(val.value);
+          } catch {
+            return val.value;
+          }
+        }
+        return val.value;
+      case "string_list":
+        if (Array.isArray(val.value)) {
+          return val.value.map((v) => String(v));
+        }
+        return [];
+      case "log_level":
+        return typeof val.value === "number" ? val.value : String(val.value ?? "");
+      case "duration":
+        return durationToMilliseconds(String(val.value ?? ""));
+      default:
+        return val.value;
+    }
+  }
+};
+function coerceValue(value, valueType) {
+  switch (valueType) {
+    case "string":
+      return value;
+    case "int": {
+      const n = parseInt(value, 10);
+      if (isNaN(n)) throw new Error(`Cannot convert "${value}" to int`);
+      return n;
+    }
+    case "double": {
+      const n = parseFloat(value);
+      if (isNaN(n)) throw new Error(`Cannot convert "${value}" to double`);
+      return n;
+    }
+    case "bool":
+      return TRUE_VALUES.has(value.toLowerCase());
+    case "string_list":
+      return value.split(/\s*,\s*/);
+    case "duration":
+      return value;
+    default:
+      return value;
+  }
+}
+function valueTypeForCoerced(valueType) {
+  switch (valueType) {
+    case "int":
+      return "int";
+    case "double":
+      return "double";
+    case "bool":
+      return "bool";
+    case "string_list":
+      return "string_list";
+    default:
+      return "string";
+  }
+}
+
+// src/transport.ts
+var SDK_VERSION = "0.1.0";
+var DEFAULT_TELEMETRY_URL = "https://telemetry.quonfig.com";
+var Transport = class {
+  baseUrl;
+  telemetryBaseUrl;
+  sdkKey;
+  etag = "";
+  constructor(baseUrl, sdkKey, telemetryBaseUrl) {
+    this.baseUrl = baseUrl.replace(/\/$/, "");
+    const envUrl = process.env.QUONFIG_TELEMETRY_URL;
+    const url = envUrl || telemetryBaseUrl || DEFAULT_TELEMETRY_URL;
+    this.telemetryBaseUrl = url.replace(/\/$/, "");
+    this.sdkKey = sdkKey;
+  }
+  /**
+   * Build the Basic auth header value.
+   * Uses username "1" like the Go SDK: base64("1:{sdkKey}")
+   */
+  getAuthHeader() {
+    return "Basic " + Buffer.from(`1:${this.sdkKey}`).toString("base64");
+  }
+  /**
+   * Common headers for all requests.
+   */
+  getHeaders(extra) {
+    return {
+      Authorization: this.getAuthHeader(),
+      "X-Quonfig-SDK-Version": `node-${SDK_VERSION}`,
+      Accept: "application/json",
+      ...extra
+    };
+  }
+  /**
+   * Fetch configs from GET /api/v2/configs with ETag caching.
+   *
+   * Returns `{ notChanged: true }` if the server responds with 304.
+   */
+  async fetchConfigs() {
+    const headers = this.getHeaders();
+    if (this.etag) {
+      headers["If-None-Match"] = this.etag;
+    }
+    const response = await fetch(`${this.baseUrl}/api/v2/configs`, {
+      method: "GET",
+      headers
+    });
+    if (response.status === 304) {
+      return { notChanged: true };
+    }
+    if (!response.ok) {
+      const body = await response.text().catch(() => "");
+      throw new Error(`Unexpected status ${response.status}: ${body}`);
+    }
+    const etag = response.headers.get("ETag");
+    if (etag) {
+      this.etag = etag;
+    }
+    const envelope = await response.json();
+    return { envelope, notChanged: false };
+  }
+  /**
+   * Post telemetry data to the telemetry endpoint.
+   */
+  async postTelemetry(data) {
+    const headers = this.getHeaders({
+      "Content-Type": "application/json"
+    });
+    const response = await fetch(`${this.telemetryBaseUrl}/api/v1/telemetry/`, {
+      method: "POST",
+      headers,
+      body: JSON.stringify(data)
+    });
+    if (!response.ok) {
+      const body = await response.text().catch(() => "");
+      console.warn(`[quonfig] Telemetry POST failed: ${response.status} ${body}`);
+    }
+  }
+  /**
+   * Get the SSE URL for config streaming.
+   */
+  getSSEUrl() {
+    return `${this.baseUrl}/api/v2/sse/config`;
+  }
+  /**
+   * Get auth headers for SSE connection.
+   */
+  getSSEHeaders() {
+    return this.getHeaders({
+      Accept: "text/event-stream"
+    });
+  }
+};
+
+// src/sse.ts
+var SSEConnection = class {
+  transport;
+  eventSource = null;
+  constructor(transport) {
+    this.transport = transport;
+  }
+  /**
+   * Start listening for SSE events.
+   *
+   * The onUpdate callback receives the new config envelope on each event.
+   */
+  start(onUpdate) {
+    this.connectSSE(onUpdate).catch((err) => {
+      console.warn("[quonfig] SSE connection failed:", err);
+    });
+  }
+  async connectSSE(onUpdate) {
+    try {
+      const EventSourceModule = await import("eventsource");
+      const EventSource = EventSourceModule.default || EventSourceModule;
+      const url = this.transport.getSSEUrl();
+      const headers = this.transport.getSSEHeaders();
+      this.eventSource = new EventSource(url, { headers });
+      this.eventSource.onmessage = (event) => {
+        try {
+          const envelope = JSON.parse(event.data);
+          onUpdate(envelope);
+        } catch (err) {
+          console.warn("[quonfig] SSE message parse error:", err);
+        }
+      };
+      this.eventSource.onerror = (err) => {
+        console.warn("[quonfig] SSE error:", err);
+      };
+    } catch (err) {
+      console.warn("[quonfig] Failed to initialize SSE:", err);
+    }
+  }
+  /**
+   * Close the SSE connection.
+   */
+  close() {
+    if (this.eventSource) {
+      this.eventSource.close();
+      this.eventSource = null;
+    }
+  }
+};
+
+// src/logger.ts
+var LOG_LEVEL_PREFIX = "log-level.";
+var WORD_LEVEL_LOOKUP = {
+  trace: 1,
+  debug: 2,
+  info: 3,
+  warn: 5,
+  error: 6,
+  fatal: 9
+};
+var NUMBER_LEVEL_LOOKUP = {
+  1: "trace",
+  2: "debug",
+  3: "info",
+  5: "warn",
+  6: "error",
+  9: "fatal"
+};
+function wordLevelToNumber(level) {
+  return WORD_LEVEL_LOOKUP[level];
+}
+function parseLevel(level) {
+  if (typeof level === "number") {
+    return level;
+  }
+  if (typeof level === "string") {
+    const lower = level.toLowerCase();
+    if (WORD_LEVEL_LOOKUP[lower] !== void 0) {
+      return WORD_LEVEL_LOOKUP[lower];
+    }
+    const n = parseInt(level, 10);
+    if (!isNaN(n) && NUMBER_LEVEL_LOOKUP[n] !== void 0) {
+      return n;
+    }
+  }
+  return void 0;
+}
+function shouldLog(args) {
+  const { loggerName, desiredLevel, defaultLevel, getConfig } = args;
+  let loggerNameWithPrefix = LOG_LEVEL_PREFIX + loggerName;
+  while (loggerNameWithPrefix.includes(".")) {
+    const resolvedLevel = getConfig(loggerNameWithPrefix);
+    if (resolvedLevel !== void 0) {
+      return Number(resolvedLevel) <= desiredLevel;
+    }
+    loggerNameWithPrefix = loggerNameWithPrefix.slice(
+      0,
+      loggerNameWithPrefix.lastIndexOf(".")
+    );
+  }
+  return defaultLevel <= desiredLevel;
+}
+
+// src/telemetry/evaluationSummaries.ts
+var EvaluationSummaryCollector = class {
+  enabled;
+  data = /* @__PURE__ */ new Map();
+  startAt;
+  maxDataSize;
+  constructor(enabled, maxDataSize = 1e4) {
+    this.enabled = enabled;
+    this.maxDataSize = maxDataSize;
+  }
+  isEnabled() {
+    return this.enabled;
+  }
+  push(evaluation) {
+    if (!this.enabled) return;
+    if (this.data.size >= this.maxDataSize) return;
+    if (evaluation.unwrappedValue === void 0) return;
+    if (evaluation.configType === "log_level") return;
+    this.startAt = this.startAt ?? Date.now();
+    const key = JSON.stringify([evaluation.configKey, evaluation.configType]);
+    const counter = JSON.stringify([
+      evaluation.configId,
+      evaluation.ruleIndex,
+      typeof evaluation.unwrappedValue,
+      evaluation.reportableValue ?? evaluation.unwrappedValue,
+      evaluation.weightedValueIndex
+    ]);
+    let countersForKey = this.data.get(key);
+    if (countersForKey === void 0) {
+      countersForKey = /* @__PURE__ */ new Map();
+      this.data.set(key, countersForKey);
+    }
+    const currentCount = countersForKey.get(counter) ?? 0;
+    countersForKey.set(counter, currentCount + 1);
+  }
+  /**
+   * Drain collected summaries into a TelemetryEvent, or return undefined if empty.
+   */
+  drain() {
+    if (this.data.size === 0) return void 0;
+    const summaries = [];
+    this.data.forEach((rawCounters, keyJSON) => {
+      const [configKey, configType] = JSON.parse(keyJSON);
+      const counters = [];
+      rawCounters.forEach((count, counterJSON) => {
+        const [configId, ruleIndex, valueType, value, weightedValueIndex] = JSON.parse(counterJSON);
+        const counter = {
+          configId,
+          conditionalValueIndex: ruleIndex,
+          configRowIndex: 0,
+          selectedValue: { [valueType]: value },
+          count
+        };
+        if (weightedValueIndex !== void 0 && weightedValueIndex >= 0) {
+          counter.weightedValueIndex = weightedValueIndex;
+        }
+        counters.push(counter);
+      });
+      summaries.push({
+        key: configKey,
+        type: configType,
+        counters
+      });
+    });
+    const event = {
+      summaries: {
+        start: this.startAt ?? Date.now(),
+        end: Date.now(),
+        summaries
+      }
+    };
+    this.data.clear();
+    this.startAt = void 0;
+    return event;
+  }
+};
+
+// src/telemetry/contextShapes.ts
+var ContextShapeCollector = class {
+  enabled;
+  data = /* @__PURE__ */ new Map();
+  maxDataSize;
+  constructor(contextUploadMode, maxDataSize = 1e4) {
+    this.enabled = contextUploadMode !== "none";
+    this.maxDataSize = maxDataSize;
+  }
+  isEnabled() {
+    return this.enabled;
+  }
+  push(contexts) {
+    if (!this.enabled) return;
+    for (const [name, ctx] of Object.entries(contexts)) {
+      for (const [key, value] of Object.entries(ctx)) {
+        let shape = this.data.get(name);
+        if (shape === void 0 && this.data.size >= this.maxDataSize) {
+          continue;
+        }
+        shape = shape ?? {};
+        if (shape[key] === void 0) {
+          shape[key] = fieldTypeForValue(value);
+          this.data.set(name, shape);
+        }
+      }
+    }
+  }
+  /**
+   * Drain collected shapes into a TelemetryEvent, or return undefined if empty.
+   */
+  drain() {
+    if (this.data.size === 0) return void 0;
+    const shapes = [];
+    this.data.forEach((shape, name) => {
+      shapes.push({ name, fieldTypes: shape });
+    });
+    this.data.clear();
+    return {
+      contextShapes: { shapes }
+    };
+  }
+};
+function fieldTypeForValue(value) {
+  if (Number.isInteger(value)) return 1;
+  if (typeof value === "number") return 4;
+  if (typeof value === "boolean") return 5;
+  if (Array.isArray(value)) return 10;
+  return 2;
+}
+
+// src/telemetry/exampleContexts.ts
+var ExampleContextCollector = class {
+  enabled;
+  data = [];
+  seen = /* @__PURE__ */ new Map();
+  maxDataSize;
+  rateLimitMs;
+  constructor(contextUploadMode, maxDataSize = 1e4, rateLimitMs = 60 * 60 * 1e3) {
+    this.enabled = contextUploadMode === "periodic_example";
+    this.maxDataSize = maxDataSize;
+    this.rateLimitMs = rateLimitMs;
+  }
+  isEnabled() {
+    return this.enabled;
+  }
+  push(contexts) {
+    if (!this.enabled) return;
+    if (this.data.length >= this.maxDataSize) return;
+    const key = this.groupedKey(contexts);
+    if (key.length === 0) return;
+    const lastSeen = this.seen.get(key);
+    if (lastSeen !== void 0 && Date.now() - lastSeen < this.rateLimitMs) {
+      return;
+    }
+    this.data.push([Date.now(), contexts]);
+    this.seen.set(key, Date.now());
+  }
+  /**
+   * Drain collected examples into a TelemetryEvent, or return undefined if empty.
+   */
+  drain() {
+    if (this.data.length === 0) return void 0;
+    const examples = this.data.map(([timestamp, contexts]) => {
+      const contextsList = Object.entries(contexts).map(([type, ctx]) => {
+        const values = {};
+        for (const [key, value] of Object.entries(ctx)) {
+          values[key] = value;
+        }
+        return { type, values };
+      });
+      return {
+        timestamp,
+        contextSet: { contexts: contextsList }
+      };
+    });
+    this.data.length = 0;
+    this.pruneCache();
+    return {
+      exampleContexts: { examples }
+    };
+  }
+  groupedKey(contexts) {
+    return Object.values(contexts).map((ctx) => {
+      const key = ctx["key"] ?? ctx["trackingId"];
+      return typeof key === "string" ? key : JSON.stringify(key);
+    }).filter((str) => str !== void 0 && str !== null && String(str).length > 0).sort().join("|");
+  }
+  pruneCache() {
+    const now = Date.now();
+    for (const [key, timestamp] of this.seen.entries()) {
+      if (now - timestamp > this.rateLimitMs) {
+        this.seen.delete(key);
+      }
+    }
+  }
+};
+
+// src/telemetry/reporter.ts
+var TelemetryReporter = class {
+  transport;
+  instanceHash;
+  evaluationSummaries;
+  contextShapes;
+  exampleContexts;
+  timer;
+  initialDelay;
+  maxDelay;
+  currentDelay;
+  stopped = false;
+  constructor(args) {
+    this.transport = args.transport;
+    this.instanceHash = args.instanceHash;
+    this.evaluationSummaries = args.evaluationSummaries;
+    this.contextShapes = args.contextShapes;
+    this.exampleContexts = args.exampleContexts;
+    this.initialDelay = args.initialDelay ?? 8e3;
+    this.maxDelay = args.maxDelay ?? 6e5;
+    this.currentDelay = this.initialDelay;
+  }
+  /**
+   * Start the periodic telemetry reporting loop.
+   */
+  start() {
+    if (this.stopped) return;
+    this.scheduleNext();
+  }
+  /**
+   * Stop telemetry reporting.
+   */
+  stop() {
+    this.stopped = true;
+    if (this.timer !== void 0) {
+      clearTimeout(this.timer);
+      this.timer = void 0;
+    }
+  }
+  scheduleNext() {
+    if (this.stopped) return;
+    this.timer = setTimeout(async () => {
+      try {
+        await this.sync();
+        this.currentDelay = this.initialDelay;
+      } catch (err) {
+        console.warn("[quonfig] Telemetry sync error:", err);
+        this.currentDelay = Math.min(this.currentDelay * 1.5, this.maxDelay);
+      } finally {
+        this.scheduleNext();
+      }
+    }, this.currentDelay);
+    if (this.timer && typeof this.timer === "object" && "unref" in this.timer) {
+      this.timer.unref();
+    }
+  }
+  async sync() {
+    const events = [];
+    const summaryEvent = this.evaluationSummaries.drain();
+    if (summaryEvent) events.push(summaryEvent);
+    const shapesEvent = this.contextShapes.drain();
+    if (shapesEvent) events.push(shapesEvent);
+    const examplesEvent = this.exampleContexts.drain();
+    if (examplesEvent) events.push(examplesEvent);
+    if (events.length === 0) return;
+    const payload = {
+      instanceHash: this.instanceHash,
+      events
+    };
+    await this.transport.postTelemetry(payload);
+  }
+};
+
+// src/quonfig.ts
+var DEFAULT_API_URL = "https://api.quonfig.com";
+var DEFAULT_POLL_INTERVAL = 6e4;
+var DEFAULT_INIT_TIMEOUT = 1e4;
+var DEFAULT_LOG_LEVEL = 5;
+var BoundQuonfig = class _BoundQuonfig {
+  client;
+  boundContexts;
+  constructor(client, contexts) {
+    this.client = client;
+    this.boundContexts = contexts;
+  }
+  get(key, contexts, defaultValue) {
+    return this.client.get(key, mergeContexts(this.boundContexts, contexts), defaultValue);
+  }
+  getString(key, contexts) {
+    return this.client.getString(key, mergeContexts(this.boundContexts, contexts));
+  }
+  getNumber(key, contexts) {
+    return this.client.getNumber(key, mergeContexts(this.boundContexts, contexts));
+  }
+  getBool(key, contexts) {
+    return this.client.getBool(key, mergeContexts(this.boundContexts, contexts));
+  }
+  getStringList(key, contexts) {
+    return this.client.getStringList(key, mergeContexts(this.boundContexts, contexts));
+  }
+  getDuration(key, contexts) {
+    return this.client.getDuration(key, mergeContexts(this.boundContexts, contexts));
+  }
+  getJSON(key, contexts) {
+    return this.client.getJSON(key, mergeContexts(this.boundContexts, contexts));
+  }
+  isFeatureEnabled(key, contexts) {
+    return this.client.isFeatureEnabled(key, mergeContexts(this.boundContexts, contexts));
+  }
+  shouldLog(args) {
+    return this.client.shouldLog({
+      ...args,
+      contexts: mergeContexts(this.boundContexts, args.contexts)
+    });
+  }
+  keys() {
+    return this.client.keys();
+  }
+  inContext(contexts) {
+    return new _BoundQuonfig(this.client, mergeContexts(this.boundContexts, contexts));
+  }
+};
+var Quonfig = class {
+  sdkKey;
+  apiUrl;
+  telemetryUrl;
+  enableSSE;
+  enablePolling;
+  pollInterval;
+  namespace;
+  onNoDefault;
+  globalContext;
+  initTimeout;
+  datafile;
+  store;
+  evaluator;
+  resolver;
+  transport;
+  sseConnection;
+  pollTimer;
+  telemetryReporter;
+  instanceHash;
+  environmentId = "";
+  initialized = false;
+  // Telemetry collectors
+  evaluationSummaries;
+  contextShapes;
+  exampleContexts;
+  constructor(options) {
+    this.sdkKey = options.sdkKey;
+    this.apiUrl = (options.apiUrl ?? DEFAULT_API_URL).replace(/\/$/, "");
+    this.telemetryUrl = options.telemetryUrl;
+    this.enableSSE = options.enableSSE ?? true;
+    this.enablePolling = options.enablePolling ?? false;
+    this.pollInterval = options.pollInterval ?? DEFAULT_POLL_INTERVAL;
+    this.namespace = options.namespace;
+    this.onNoDefault = options.onNoDefault ?? "error";
+    this.globalContext = options.globalContext;
+    this.initTimeout = options.initTimeout ?? DEFAULT_INIT_TIMEOUT;
+    this.datafile = options.datafile;
+    this.instanceHash = (0, import_crypto3.randomUUID)();
+    this.store = new ConfigStore();
+    this.evaluator = new Evaluator(this.store);
+    this.resolver = new Resolver(this.store, this.evaluator);
+    this.transport = new Transport(this.apiUrl, this.sdkKey, this.telemetryUrl);
+    const contextUploadMode = options.contextUploadMode ?? "periodic_example";
+    this.evaluationSummaries = new EvaluationSummaryCollector(
+      options.collectEvaluationSummaries ?? true
+    );
+    this.contextShapes = new ContextShapeCollector(contextUploadMode);
+    this.exampleContexts = new ExampleContextCollector(contextUploadMode);
+  }
+  /**
+   * Initialize the SDK. Downloads configs from the API (or loads from datafile)
+   * and starts background update mechanisms (SSE/polling).
+   *
+   * Must be called before using any get* methods.
+   */
+  async init() {
+    if (this.datafile) {
+      this.loadDatafile();
+      this.initialized = true;
+      return;
+    }
+    const fetchPromise = this.fetchAndInstall();
+    const timeoutPromise = new Promise((_, reject) => {
+      setTimeout(() => reject(new Error("Initialization timed out")), this.initTimeout);
+    });
+    try {
+      await Promise.race([fetchPromise, timeoutPromise]);
+    } catch (err) {
+      console.warn("[quonfig] Initialization failed:", err);
+      throw err;
+    }
+    this.initialized = true;
+    if (this.enableSSE) {
+      this.startSSE();
+    }
+    if (this.enablePolling) {
+      this.startPolling();
+    }
+    this.startTelemetry();
+  }
+  /**
+   * Get a config value by key. Evaluates rules against the provided context.
+   */
+  get(key, contexts, defaultValue) {
+    this.requireInitialized();
+    const mergedContexts = mergeContexts(this.globalContext, contexts);
+    const config = this.store.get(key);
+    if (config === void 0) {
+      return this.handleNoDefault(key, defaultValue);
+    }
+    this.contextShapes.push(mergedContexts);
+    this.exampleContexts.push(mergedContexts);
+    const match = this.evaluator.evaluateConfig(
+      config,
+      this.environmentId,
+      mergedContexts
+    );
+    if (!match.isMatch || match.value === void 0) {
+      return this.handleNoDefault(key, defaultValue);
+    }
+    const { resolved, reportableValue } = this.resolver.resolveValue(
+      match.value,
+      config.key,
+      config.valueType,
+      this.environmentId,
+      mergedContexts
+    );
+    const unwrapped = this.resolver.unwrapValue(resolved);
+    const evaluation = {
+      configId: config.id,
+      configKey: config.key,
+      configType: config.type,
+      unwrappedValue: unwrapped,
+      reportableValue,
+      ruleIndex: match.ruleIndex,
+      weightedValueIndex: match.weightedValueIndex >= 0 ? match.weightedValueIndex : void 0
+    };
+    this.evaluationSummaries.push(evaluation);
+    return unwrapped;
+  }
+  /**
+   * Get a string config value.
+   */
+  getString(key, contexts) {
+    const value = this.get(key, contexts, void 0);
+    if (value === void 0) return void 0;
+    return String(value);
+  }
+  /**
+   * Get a number config value.
+   */
+  getNumber(key, contexts) {
+    const value = this.get(key, contexts, void 0);
+    if (value === void 0) return void 0;
+    return typeof value === "number" ? value : Number(value);
+  }
+  /**
+   * Get a boolean config value.
+   */
+  getBool(key, contexts) {
+    const value = this.get(key, contexts, void 0);
+    if (value === void 0) return void 0;
+    return !!value;
+  }
+  /**
+   * Get a string list config value.
+   */
+  getStringList(key, contexts) {
+    const value = this.get(key, contexts, void 0);
+    if (value === void 0) return void 0;
+    if (Array.isArray(value)) return value.map((v) => String(v));
+    return void 0;
+  }
+  /**
+   * Get a duration config value in milliseconds.
+   */
+  getDuration(key, contexts) {
+    const value = this.get(key, contexts, void 0);
+    if (value === void 0) return void 0;
+    if (typeof value === "number") return value;
+    if (typeof value === "string") return durationToMilliseconds(value);
+    return void 0;
+  }
+  /**
+   * Get a JSON config value (parsed).
+   */
+  getJSON(key, contexts) {
+    const value = this.get(key, contexts, void 0);
+    if (value === void 0) return void 0;
+    return value;
+  }
+  /**
+   * Check if a feature flag is enabled.
+   * Returns false if the key is not found or the value is not a boolean.
+   */
+  isFeatureEnabled(key, contexts) {
+    const value = this.get(key, contexts, void 0);
+    if (typeof value === "boolean") return value;
+    if (value === "true") return true;
+    if (value === "false") return false;
+    return false;
+  }
+  /**
+   * Check if a log message should be logged at the given level.
+   */
+  shouldLog(args) {
+    const desiredLevelNum = parseLevel(args.desiredLevel);
+    if (desiredLevelNum === void 0) {
+      console.warn(`[quonfig] Invalid desiredLevel "${args.desiredLevel}". Returning true.`);
+      return true;
+    }
+    const defaultLevelNum = parseLevel(args.defaultLevel) ?? DEFAULT_LOG_LEVEL;
+    return shouldLog({
+      loggerName: args.loggerName,
+      desiredLevel: desiredLevelNum,
+      defaultLevel: defaultLevelNum,
+      getConfig: (logKey) => {
+        try {
+          return this.get(logKey, args.contexts, void 0);
+        } catch {
+          return void 0;
+        }
+      }
+    });
+  }
+  /**
+   * Get all config keys currently in the store.
+   */
+  keys() {
+    this.requireInitialized();
+    return this.store.keys();
+  }
+  /**
+   * Get the raw ConfigResponse for a key (for advanced usage / CLI tooling).
+   */
+  rawConfig(key) {
+    this.requireInitialized();
+    return this.store.get(key);
+  }
+  /**
+   * Create a BoundQuonfig with the given context baked in.
+   */
+  inContext(contexts) {
+    return new BoundQuonfig(this, mergeContexts(this.globalContext, contexts));
+  }
+  /**
+   * Close the SDK. Stops SSE, polling, and telemetry.
+   */
+  close() {
+    if (this.sseConnection) {
+      this.sseConnection.close();
+      this.sseConnection = void 0;
+    }
+    if (this.pollTimer) {
+      clearTimeout(this.pollTimer);
+      this.pollTimer = void 0;
+    }
+    if (this.telemetryReporter) {
+      this.telemetryReporter.stop();
+      this.telemetryReporter = void 0;
+    }
+  }
+  // ---- Private methods ----
+  requireInitialized() {
+    if (!this.initialized) {
+      throw new Error("[quonfig] Not initialized. Call init() first.");
+    }
+  }
+  handleNoDefault(key, defaultValue) {
+    if (defaultValue !== void 0) {
+      return defaultValue;
+    }
+    switch (this.onNoDefault) {
+      case "error":
+        throw new Error(`No value found for key "${key}"`);
+      case "warn":
+        console.warn(`[quonfig] No value found for key "${key}"`);
+        return void 0;
+      case "ignore":
+        return void 0;
+    }
+  }
+  loadDatafile() {
+    let data;
+    if (typeof this.datafile === "string") {
+      const raw = (0, import_fs.readFileSync)(this.datafile, "utf-8");
+      data = JSON.parse(raw);
+    } else if (typeof this.datafile === "object") {
+      data = this.datafile;
+    } else {
+      throw new Error("Invalid datafile option");
+    }
+    this.store.update(data);
+    this.environmentId = data.meta.environment;
+  }
+  async fetchAndInstall() {
+    const result = await this.transport.fetchConfigs();
+    if (result.notChanged) {
+      return;
+    }
+    if (result.envelope) {
+      this.store.update(result.envelope);
+      this.environmentId = result.envelope.meta.environment;
+    }
+  }
+  startSSE() {
+    this.sseConnection = new SSEConnection(this.transport);
+    this.sseConnection.start((envelope) => {
+      this.store.update(envelope);
+      this.environmentId = envelope.meta.environment;
+    });
+  }
+  startPolling() {
+    const poll = () => {
+      this.fetchAndInstall().catch((err) => {
+        console.warn("[quonfig] Polling error:", err);
+      }).finally(() => {
+        this.pollTimer = setTimeout(poll, this.pollInterval);
+        if (this.pollTimer && typeof this.pollTimer === "object" && "unref" in this.pollTimer) {
+          this.pollTimer.unref();
+        }
+      });
+    };
+    this.pollTimer = setTimeout(poll, this.pollInterval);
+    if (this.pollTimer && typeof this.pollTimer === "object" && "unref" in this.pollTimer) {
+      this.pollTimer.unref();
+    }
+  }
+  startTelemetry() {
+    const anyEnabled = this.evaluationSummaries.isEnabled() || this.contextShapes.isEnabled() || this.exampleContexts.isEnabled();
+    if (!anyEnabled) return;
+    this.telemetryReporter = new TelemetryReporter({
+      transport: this.transport,
+      instanceHash: this.instanceHash,
+      evaluationSummaries: this.evaluationSummaries,
+      contextShapes: this.contextShapes,
+      exampleContexts: this.exampleContexts
+    });
+    this.telemetryReporter.start();
+  }
+};
+
+// src/types.ts
+var ConfigType = {
+  FeatureFlag: "feature_flag",
+  Config: "config",
+  Segment: "segment",
+  LogLevel: "log_level",
+  Schema: "schema"
+};
+var ProvidedSource = {
+  EnvVar: "ENV_VAR"
+};
+
+// src/cli-compat.ts
+var Client = class {
+  jwt;
+  sdkKey;
+  apiUrl;
+  clientIdentifier;
+  log;
+  constructor(options) {
+    this.jwt = options.jwt;
+    this.sdkKey = options.sdkKey;
+    this.apiUrl = options.apiUrl.replace(/\/$/, "");
+    this.clientIdentifier = options.clientIdentifier;
+    this.log = options.log ?? (() => {
+    });
+  }
+  headers() {
+    const h = {
+      "Content-Type": "application/json",
+      "X-Client-Version": this.clientIdentifier
+    };
+    if (this.jwt) {
+      h["Authorization"] = `Bearer ${this.jwt}`;
+    } else if (this.sdkKey) {
+      h["Authorization"] = `Basic ${Buffer.from(this.sdkKey).toString("base64")}`;
+    }
+    return h;
+  }
+  async get(path) {
+    const url = `${this.apiUrl}${path}`;
+    this.log("ApiClient", `GET ${url}`);
+    return fetch(url, { method: "GET", headers: this.headers() });
+  }
+  async post(path, payload) {
+    const url = `${this.apiUrl}${path}`;
+    this.log("ApiClient", `POST ${url}`);
+    return fetch(url, {
+      method: "POST",
+      headers: this.headers(),
+      body: JSON.stringify(payload)
+    });
+  }
+  async put(path, payload) {
+    const url = `${this.apiUrl}${path}`;
+    this.log("ApiClient", `PUT ${url}`);
+    return fetch(url, {
+      method: "PUT",
+      headers: this.headers(),
+      body: JSON.stringify(payload)
+    });
+  }
+};
+function getProjectEnvFromSdkKey(sdkKey) {
+  const parts = sdkKey.split("-");
+  if (parts.length < 2) {
+    throw new Error(`Invalid SDK key format: cannot extract projectEnvId`);
+  }
+  return {
+    id: parts.slice(0, 2).join("-"),
+    projectId: Number.parseInt(parts[0], 10) || 0
+  };
+}
+var ConfigValueType = /* @__PURE__ */ ((ConfigValueType2) => {
+  ConfigValueType2[ConfigValueType2["NotSetValue"] = 0] = "NotSetValue";
+  ConfigValueType2[ConfigValueType2["Int"] = 1] = "Int";
+  ConfigValueType2[ConfigValueType2["String"] = 2] = "String";
+  ConfigValueType2[ConfigValueType2["Bytes"] = 3] = "Bytes";
+  ConfigValueType2[ConfigValueType2["Double"] = 4] = "Double";
+  ConfigValueType2[ConfigValueType2["Bool"] = 5] = "Bool";
+  ConfigValueType2[ConfigValueType2["LimitDefinition"] = 7] = "LimitDefinition";
+  ConfigValueType2[ConfigValueType2["LogLevel"] = 8] = "LogLevel";
+  ConfigValueType2[ConfigValueType2["StringList"] = 9] = "StringList";
+  ConfigValueType2[ConfigValueType2["IntRange"] = 10] = "IntRange";
+  ConfigValueType2[ConfigValueType2["Duration"] = 11] = "Duration";
+  ConfigValueType2[ConfigValueType2["Json"] = 12] = "Json";
+  return ConfigValueType2;
+})(ConfigValueType || {});
+function valueTypeStringForConfig(config) {
+  return config.valueType;
+}
+
+// src/index.ts
+var encryption = {
+  encrypt,
+  generateNewHexKey
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BoundQuonfig,
+  Client,
+  ConfigStore,
+  ConfigType,
+  ConfigValueType,
+  ContextShapeCollector,
+  EvaluationSummaryCollector,
+  Evaluator,
+  ExampleContextCollector,
+  LOG_LEVEL_PREFIX,
+  OP_ALWAYS_TRUE,
+  OP_HIERARCHICAL_MATCH,
+  OP_IN_INT_RANGE,
+  OP_IN_SEG,
+  OP_NOT_IN_SEG,
+  OP_NOT_SET,
+  OP_PROP_AFTER,
+  OP_PROP_BEFORE,
+  OP_PROP_CONTAINS_ONE_OF,
+  OP_PROP_DOES_NOT_CONTAIN_ONE_OF,
+  OP_PROP_DOES_NOT_END_WITH_ONE_OF,
+  OP_PROP_DOES_NOT_MATCH,
+  OP_PROP_DOES_NOT_START_WITH_ONE_OF,
+  OP_PROP_ENDS_WITH_ONE_OF,
+  OP_PROP_GREATER_THAN,
+  OP_PROP_GREATER_THAN_OR_EQUAL,
+  OP_PROP_IS_NOT_ONE_OF,
+  OP_PROP_IS_ONE_OF,
+  OP_PROP_LESS_THAN,
+  OP_PROP_LESS_THAN_OR_EQUAL,
+  OP_PROP_MATCHES,
+  OP_PROP_SEMVER_EQUAL,
+  OP_PROP_SEMVER_GREATER_THAN,
+  OP_PROP_SEMVER_LESS_THAN,
+  OP_PROP_STARTS_WITH_ONE_OF,
+  ProvidedSource,
+  Quonfig,
+  Resolver,
+  TelemetryReporter,
+  Transport,
+  WeightedValueResolver,
+  compareSemver,
+  contextLookup,
+  decrypt,
+  durationToMilliseconds,
+  encrypt,
+  encryption,
+  evaluateCriterion,
+  generateNewHexKey,
+  getContextValue,
+  getProjectEnvFromSdkKey,
+  hashZeroToOne,
+  mergeContexts,
+  parseLevel,
+  parseSemver,
+  shouldLog,
+  valueTypeStringForConfig,
+  wordLevelToNumber
+});
+//# sourceMappingURL=index.cjs.map