@variantlab/core 0.1.0

package/dist/_size/engine.cjs

@@ -0,0 +1,1178 @@
+'use strict';
+
+// src/engine/crash-counter.ts
+var CrashCounter = class {
+  constructor() {
+    this.crashes = /* @__PURE__ */ new Map();
+  }
+  /** Record a crash; returns the new in-window count (post-prune). */
+  record(experimentId, now, window) {
+    const list = this.crashes.get(experimentId) ?? [];
+    list.push(now);
+    this.crashes.set(experimentId, list);
+    return this.countWithin(experimentId, now, window);
+  }
+  countWithin(experimentId, now, window) {
+    const list = this.crashes.get(experimentId);
+    if (list === void 0) return 0;
+    const cutoff = now - window;
+    let i = 0;
+    while (i < list.length && (list[i] ?? 0) < cutoff) i++;
+    if (i > 0) list.splice(0, i);
+    return list.length;
+  }
+  clear(experimentId) {
+    if (experimentId === void 0) this.crashes.clear();
+    else this.crashes.delete(experimentId);
+  }
+};
+
+// src/targeting/glob.ts
+function compileGlob(pattern) {
+  if (pattern.length === 0) return null;
+  if (pattern === "*") return [{ kind: "param" }];
+  if (pattern === "**") return [{ kind: "rest" }];
+  if (pattern[0] !== "/") return null;
+  if (pattern.indexOf("***") >= 0) return null;
+  const normalized = pattern.length > 1 && pattern.endsWith("/") ? pattern.slice(0, -1) : pattern;
+  if (normalized === "/") return [];
+  const raw = normalized.slice(1).split("/");
+  const segs = [];
+  for (let i = 0; i < raw.length; i++) {
+    const part = raw[i];
+    if (part.length === 0) return null;
+    if (part === "**") {
+      if (i !== raw.length - 1) return null;
+      segs.push({ kind: "rest" });
+      continue;
+    }
+    if (part === "*") {
+      segs.push({ kind: "param" });
+      continue;
+    }
+    if (part[0] === ":") {
+      if (part.length < 2) return null;
+      segs.push({ kind: "param" });
+      continue;
+    }
+    if (/[*:?[\]{}!]/.test(part)) return null;
+    segs.push({ kind: "literal", value: part });
+  }
+  return segs;
+}
+function matchCompiledRoute(segs, path) {
+  if (path.length === 0) return false;
+  if (path[0] !== "/") return false;
+  const normalized = path.length > 1 && path.endsWith("/") ? path.slice(0, -1) : path;
+  if (segs.length === 0) return normalized === "/";
+  const parts = normalized === "/" ? [] : normalized.slice(1).split("/");
+  for (let i = 0; i < segs.length; i++) {
+    const seg = segs[i];
+    if (seg.kind === "rest") {
+      return true;
+    }
+    if (i >= parts.length) return false;
+    const part = parts[i];
+    if (part.length === 0) return false;
+    if (seg.kind === "literal") {
+      if (seg.value !== part) return false;
+    }
+  }
+  return parts.length === segs.length;
+}
+function matchRoute(pattern, path) {
+  const segs = compileGlob(pattern);
+  if (segs === null) return false;
+  return matchCompiledRoute(segs, path);
+}
+
+// src/targeting/semver.ts
+function parseVersion(s) {
+  if (s.length === 0) return null;
+  const parts = [0, 0, 0];
+  let idx = 0;
+  let part = 0;
+  let seen = false;
+  for (let i = 0; i < s.length; i++) {
+    const c = s.charCodeAt(i);
+    if (c === 46) {
+      if (!seen) return null;
+      parts[idx++] = part;
+      if (idx > 2) return null;
+      part = 0;
+      seen = false;
+    } else if (c >= 48 && c <= 57) {
+      part = part * 10 + (c - 48);
+      seen = true;
+    } else return null;
+  }
+  if (!seen || idx !== 2) return null;
+  parts[2] = part;
+  return [parts[0], parts[1], parts[2]];
+}
+function cmpVersion(a, b) {
+  return a[0] - b[0] || a[1] - b[1] || a[2] - b[2];
+}
+function parseSemver(s) {
+  if (s.length === 0) return null;
+  const clauses = [];
+  for (const part of s.split("||")) {
+    const c = parseClause(part.trim());
+    if (c === null) return null;
+    clauses.push(c);
+  }
+  return clauses;
+}
+function parseClause(s) {
+  if (s.length === 0) return null;
+  const hy = s.indexOf(" - ");
+  if (hy >= 0) {
+    const lo = parseVersion(s.slice(0, hy).trim());
+    const hi = parseVersion(s.slice(hy + 3).trim());
+    if (lo === null || hi === null) return null;
+    return [
+      { op: ">=", v: lo },
+      { op: "<=", v: hi }
+    ];
+  }
+  const cmps = [];
+  for (const tok of s.split(/\s+/)) {
+    if (tok.length === 0) continue;
+    const parsed = parseComparator(tok);
+    if (parsed === null) return null;
+    for (const c of parsed) cmps.push(c);
+  }
+  return cmps.length > 0 ? cmps : null;
+}
+function parseComparator(s) {
+  const c0 = s[0];
+  if (c0 === "^" || c0 === "~") {
+    const v2 = parseVersion(s.slice(1));
+    if (v2 === null) return null;
+    const upper = c0 === "^" ? [v2[0] + 1, 0, 0] : [v2[0], v2[1] + 1, 0];
+    return [
+      { op: ">=", v: v2 },
+      { op: "<", v: upper }
+    ];
+  }
+  let op = "=";
+  let rest = s;
+  if (c0 === ">" || c0 === "<") {
+    if (s[1] === "=") {
+      op = `${c0}=`;
+      rest = s.slice(2);
+    } else {
+      op = c0;
+      rest = s.slice(1);
+    }
+  } else if (c0 === "=") {
+    rest = s.slice(1);
+  }
+  const v = parseVersion(rest);
+  return v === null ? null : [{ op, v }];
+}
+function matchCompiled(range, version) {
+  for (const clause of range) if (matchClause(clause, version)) return true;
+  return false;
+}
+function matchClause(clause, version) {
+  for (const c of clause) {
+    const d = cmpVersion(version, c.v);
+    const op = c.op;
+    const fail = op === "=" ? d !== 0 : op === "<" ? d >= 0 : op === "<=" ? d > 0 : op === ">" ? d <= 0 : d < 0;
+    if (fail) return false;
+  }
+  return true;
+}
+function matchSemver(range, version) {
+  const r = parseSemver(range);
+  if (r === null) return false;
+  const v = parseVersion(version);
+  return v !== null && matchCompiled(r, v);
+}
+
+// src/config/errors.ts
+var ConfigValidationError = class extends Error {
+  constructor(issues) {
+    super(`Config validation failed with ${issues.length} issue(s)`);
+    this.name = "ConfigValidationError";
+    this.issues = Object.freeze(issues.slice());
+  }
+};
+
+// src/config/freeze.ts
+function deepFreeze(value) {
+  if (value === null || typeof value !== "object") {
+    return value;
+  }
+  if (Object.isFrozen(value)) {
+    return value;
+  }
+  if (Array.isArray(value)) {
+    for (let i = 0; i < value.length; i++) {
+      deepFreeze(value[i]);
+    }
+    return Object.freeze(value);
+  }
+  const obj = value;
+  const keys = Object.keys(obj);
+  for (let i = 0; i < keys.length; i++) {
+    deepFreeze(obj[keys[i]]);
+  }
+  return Object.freeze(value);
+}
+
+// src/config/validator.ts
+var MAX_BYTES = 1048576;
+var MAX_EXP = 1e3;
+var MAX_VAR = 100;
+var MIN_VAR = 2;
+var MAX_ROUTES = 100;
+var MAX_DEPTH = 10;
+var MAX_NAME = 128;
+var MAX_DESC = 512;
+var ID_RE = /^[a-z0-9][a-z0-9-]{0,63}$/;
+var RESERVED = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
+var ASSIGNS = /* @__PURE__ */ new Set(["default", "random", "sticky-hash", "weighted"]);
+var STATUSES = /* @__PURE__ */ new Set(["draft", "active", "archived"]);
+var TYPES = /* @__PURE__ */ new Set(["render", "value"]);
+var PLATFORMS = /* @__PURE__ */ new Set(["ios", "android", "web", "node"]);
+var SIZES = /* @__PURE__ */ new Set(["small", "medium", "large"]);
+function validateConfig(input) {
+  const issues = [];
+  if (measureBytes(input) > MAX_BYTES) {
+    push(issues, "", "config-too-large");
+    throw new ConfigValidationError(issues);
+  }
+  let parsed = input;
+  if (typeof input === "string") {
+    try {
+      parsed = JSON.parse(input);
+    } catch (err) {
+      push(issues, "", "invalid-json", err.message);
+      throw new ConfigValidationError(issues);
+    }
+  }
+  if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+    push(issues, "", "not-an-object");
+    throw new ConfigValidationError(issues);
+  }
+  const sanitized = sanitize(parsed, issues, "");
+  validateRoot(sanitized, issues);
+  if (issues.length > 0) {
+    throw new ConfigValidationError(issues);
+  }
+  return deepFreeze(sanitized);
+}
+var encoder = new TextEncoder();
+function measureBytes(input) {
+  if (typeof input === "string") return encoder.encode(input).length;
+  try {
+    const s = JSON.stringify(input);
+    if (typeof s !== "string") return 0;
+    return encoder.encode(s).length;
+  } catch {
+    return 0;
+  }
+}
+function sanitize(value, issues, ptr) {
+  if (value === null || typeof value !== "object") return value;
+  if (Array.isArray(value)) {
+    const out = [];
+    for (let i = 0; i < value.length; i++) {
+      out.push(sanitize(value[i], issues, `${ptr}/${i}`));
+    }
+    return out;
+  }
+  const src = value;
+  const dst = /* @__PURE__ */ Object.create(null);
+  const keys = Object.keys(src);
+  for (let i = 0; i < keys.length; i++) {
+    const k = keys[i];
+    if (RESERVED.has(k)) {
+      push(issues, jp(ptr, k), "reserved-key", k);
+      continue;
+    }
+    dst[k] = sanitize(src[k], issues, jp(ptr, k));
+  }
+  return dst;
+}
+function validateRoot(root, issues) {
+  const version = root["version"];
+  if (version === void 0) {
+    push(issues, "/version", "version/missing");
+  } else if (version !== 1) {
+    push(issues, "/version", "version/invalid");
+  }
+  const enabled = root["enabled"];
+  if (enabled !== void 0 && typeof enabled !== "boolean") {
+    push(issues, "/enabled", "enabled/invalid");
+  }
+  const signature = root["signature"];
+  if (signature !== void 0 && (typeof signature !== "string" || signature.length === 0)) {
+    push(issues, "/signature", "signature/invalid");
+  }
+  const experiments = root["experiments"];
+  if (experiments === void 0) {
+    push(issues, "/experiments", "experiments/missing");
+    return;
+  }
+  if (!Array.isArray(experiments)) {
+    push(issues, "/experiments", "experiments/not-an-array");
+    return;
+  }
+  if (experiments.length > MAX_EXP) {
+    push(issues, "/experiments", "experiments/too-many");
+  }
+  const seen = /* @__PURE__ */ new Set();
+  for (let i = 0; i < experiments.length; i++) {
+    validateExperiment(experiments[i], `/experiments/${i}`, seen, issues);
+  }
+}
+function validateExperiment(exp, p, seen, issues) {
+  if (exp === null || typeof exp !== "object" || Array.isArray(exp)) {
+    push(issues, p, "experiment/not-an-object");
+    return;
+  }
+  const e = exp;
+  const id = e["id"];
+  if (id === void 0) {
+    push(issues, `${p}/id`, "experiment/missing-required", "id");
+  } else if (typeof id !== "string" || !ID_RE.test(id)) {
+    push(issues, `${p}/id`, "experiment/id/invalid");
+  } else if (seen.has(id)) {
+    push(issues, `${p}/id`, "experiment/id/duplicate", id);
+  } else {
+    seen.add(id);
+  }
+  const name = e["name"];
+  if (name === void 0) {
+    push(issues, `${p}/name`, "experiment/missing-required", "name");
+  } else if (typeof name !== "string" || name.length === 0 || name.length > MAX_NAME) {
+    push(issues, `${p}/name`, "experiment/name/invalid");
+  }
+  checkOptString(
+    e["description"],
+    `${p}/description`,
+    MAX_DESC,
+    "experiment/description/invalid",
+    issues
+  );
+  checkEnum(e["type"], `${p}/type`, TYPES, "experiment/type/invalid", issues);
+  checkEnum(e["status"], `${p}/status`, STATUSES, "experiment/status/invalid", issues);
+  checkOptString(e["mutex"], `${p}/mutex`, MAX_NAME, "experiment/mutex/invalid", issues);
+  checkOptString(e["owner"], `${p}/owner`, MAX_NAME, "experiment/owner/invalid", issues);
+  checkOptBool(e["overridable"], `${p}/overridable`, "experiment/overridable/invalid", issues);
+  const variantIds = validateVariants(e["variants"], p, issues);
+  validateDefault(e["default"], variantIds, p, issues);
+  validateAssignment(e["assignment"], e["split"], variantIds, p, issues);
+  validateRoutes(e["routes"], p, issues);
+  validateTargeting(e["targeting"], p, issues);
+  validateDates(e["startDate"], e["endDate"], p, issues);
+  validateRollback(e["rollback"], p, issues);
+}
+function validateVariants(field, p, issues) {
+  const ids = /* @__PURE__ */ new Set();
+  const vp = `${p}/variants`;
+  if (field === void 0) {
+    push(issues, vp, "experiment/variants/missing");
+    return ids;
+  }
+  if (!Array.isArray(field)) {
+    push(issues, vp, "experiment/variants/missing");
+    return ids;
+  }
+  if (field.length < MIN_VAR) {
+    push(issues, vp, "experiment/variants/too-few");
+  }
+  if (field.length > MAX_VAR) {
+    push(issues, vp, "experiment/variants/too-many");
+  }
+  for (let i = 0; i < field.length; i++) {
+    const v = field[i];
+    const vip = `${vp}/${i}`;
+    if (v === null || typeof v !== "object" || Array.isArray(v)) {
+      push(issues, vip, "variant/not-an-object");
+      continue;
+    }
+    const vo = v;
+    const vid = vo["id"];
+    if (vid === void 0) {
+      push(issues, `${vip}/id`, "experiment/missing-required", "variant.id");
+    } else if (typeof vid !== "string" || !ID_RE.test(vid)) {
+      push(issues, `${vip}/id`, "variant/id/invalid");
+    } else if (ids.has(vid)) {
+      push(issues, `${vip}/id`, "variant/id/duplicate", vid);
+    } else {
+      ids.add(vid);
+    }
+    checkOptString(vo["label"], `${vip}/label`, MAX_NAME, "variant/label/invalid", issues);
+    checkOptString(
+      vo["description"],
+      `${vip}/description`,
+      MAX_DESC,
+      "variant/description/invalid",
+      issues
+    );
+  }
+  return ids;
+}
+function validateDefault(field, ids, p, issues) {
+  const dp = `${p}/default`;
+  if (field === void 0) {
+    push(issues, dp, "experiment/default/missing");
+    return;
+  }
+  if (typeof field !== "string") {
+    push(issues, dp, "experiment/default/unknown-variant");
+    return;
+  }
+  if (ids.size > 0 && !ids.has(field)) {
+    push(issues, dp, "experiment/default/unknown-variant", field);
+  }
+}
+function validateAssignment(aField, sField, ids, p, issues) {
+  let strategy = "default";
+  if (aField !== void 0) {
+    if (typeof aField !== "string" || !ASSIGNS.has(aField)) {
+      push(issues, `${p}/assignment`, "experiment/assignment/invalid");
+    } else {
+      strategy = aField;
+    }
+  }
+  const sp = `${p}/split`;
+  if (strategy === "weighted" && sField === void 0) {
+    push(issues, sp, "split/missing");
+    return;
+  }
+  if (sField === void 0) return;
+  if (sField === null || typeof sField !== "object" || Array.isArray(sField)) {
+    push(issues, sp, "split/not-an-object");
+    return;
+  }
+  const split = sField;
+  const keys = Object.keys(split);
+  let sum = 0;
+  let bad = false;
+  for (let i = 0; i < keys.length; i++) {
+    const k = keys[i];
+    if (ids.size > 0 && !ids.has(k)) {
+      push(issues, `${sp}/${esc(k)}`, "split/unknown-variant", k);
+      bad = true;
+      continue;
+    }
+    const v = split[k];
+    if (typeof v !== "number" || !Number.isInteger(v) || v < 0 || v > 100) {
+      push(issues, `${sp}/${esc(k)}`, "split/value-invalid");
+      bad = true;
+      continue;
+    }
+    sum += v;
+  }
+  if (!bad && sum !== 100) {
+    push(issues, sp, "split/sum-invalid", String(sum));
+  }
+}
+function validateRoutes(field, p, issues) {
+  if (field === void 0) return;
+  const rp = `${p}/routes`;
+  if (!Array.isArray(field)) {
+    push(issues, rp, "experiment/routes/invalid");
+    return;
+  }
+  if (field.length > MAX_ROUTES) {
+    push(issues, rp, "experiment/routes/invalid");
+  }
+  for (let i = 0; i < field.length; i++) {
+    const r = field[i];
+    if (typeof r !== "string" || compileGlob(r) === null) {
+      push(issues, `${rp}/${i}`, "route/glob/invalid");
+    }
+  }
+}
+function validateTargeting(field, p, issues) {
+  if (field === void 0) return;
+  const tp = `${p}/targeting`;
+  if (field === null || typeof field !== "object" || Array.isArray(field)) {
+    push(issues, tp, "targeting/not-an-object");
+    return;
+  }
+  if (depthOf(field, 0) > MAX_DEPTH) {
+    push(issues, tp, "targeting/depth-exceeded");
+  }
+  const t = field;
+  if (t["platform"] !== void 0) {
+    checkEnumArray(
+      t["platform"],
+      `${tp}/platform`,
+      PLATFORMS,
+      "targeting/platform/invalid",
+      issues
+    );
+  }
+  if (t["appVersion"] !== void 0) {
+    const v = t["appVersion"];
+    if (typeof v !== "string" || parseSemver(v) === null) {
+      push(issues, `${tp}/appVersion`, "targeting/appversion/invalid");
+    }
+  }
+  if (t["locale"] !== void 0) {
+    checkStringArray(t["locale"], `${tp}/locale`, "targeting/locale/invalid", issues);
+  }
+  if (t["screenSize"] !== void 0) {
+    checkEnumArray(
+      t["screenSize"],
+      `${tp}/screenSize`,
+      SIZES,
+      "targeting/screensize/invalid",
+      issues
+    );
+  }
+  if (t["routes"] !== void 0) {
+    const r = t["routes"];
+    if (!Array.isArray(r) || r.length === 0) {
+      push(issues, `${tp}/routes`, "targeting/routes/invalid");
+    } else {
+      for (let i = 0; i < r.length; i++) {
+        const v = r[i];
+        if (typeof v !== "string" || compileGlob(v) === null) {
+          push(issues, `${tp}/routes/${i}`, "targeting/routes/invalid");
+        }
+      }
+    }
+  }
+  if (t["userId"] !== void 0) {
+    validateUserId(t["userId"], `${tp}/userId`, issues);
+  }
+  if (t["attributes"] !== void 0) {
+    const a = t["attributes"];
+    if (a === null || typeof a !== "object" || Array.isArray(a)) {
+      push(issues, `${tp}/attributes`, "targeting/attributes/invalid");
+    }
+  }
+}
+function validateUserId(u, p, issues) {
+  const code = "targeting/userid/invalid";
+  if (Array.isArray(u)) {
+    if (u.length === 0) {
+      push(issues, p, code);
+      return;
+    }
+    for (let i = 0; i < u.length; i++) {
+      const v = u[i];
+      if (typeof v !== "string" || v.length === 0) {
+        push(issues, `${p}/${i}`, code);
+      }
+    }
+    return;
+  }
+  if (u !== null && typeof u === "object") {
+    const o = u;
+    const h = o["hash"];
+    const m = o["mod"];
+    if (typeof h !== "string" || h.length === 0) {
+      push(issues, `${p}/hash`, code);
+    }
+    if (typeof m !== "number" || !Number.isInteger(m) || m < 0 || m > 100) {
+      push(issues, `${p}/mod`, code);
+    }
+    return;
+  }
+  push(issues, p, code);
+}
+function validateDates(sField, eField, p, issues) {
+  let s;
+  let e;
+  if (sField !== void 0) {
+    if (typeof sField !== "string" || !isValidIsoDate(sField)) {
+      push(issues, `${p}/startDate`, "experiment/startdate/invalid");
+    } else {
+      s = Date.parse(sField);
+    }
+  }
+  if (eField !== void 0) {
+    if (typeof eField !== "string" || !isValidIsoDate(eField)) {
+      push(issues, `${p}/endDate`, "experiment/enddate/invalid");
+    } else {
+      e = Date.parse(eField);
+    }
+  }
+  if (s !== void 0 && e !== void 0 && !(e > s)) {
+    push(issues, `${p}/endDate`, "experiment/date-range/invalid");
+  }
+}
+function validateRollback(field, p, issues) {
+  if (field === void 0) return;
+  const rp = `${p}/rollback`;
+  if (field === null || typeof field !== "object" || Array.isArray(field)) {
+    push(issues, rp, "rollback/not-an-object");
+    return;
+  }
+  const r = field;
+  const thr = r["threshold"];
+  if (thr === void 0) {
+    push(issues, `${rp}/threshold`, "rollback/threshold/invalid");
+  } else if (typeof thr !== "number" || !Number.isInteger(thr) || thr < 1 || thr > 100) {
+    push(issues, `${rp}/threshold`, "rollback/threshold/invalid");
+  }
+  const win = r["window"];
+  if (win === void 0) {
+    push(issues, `${rp}/window`, "rollback/window/invalid");
+  } else if (typeof win !== "number" || !Number.isInteger(win) || win < 1e3 || win > 36e5) {
+    push(issues, `${rp}/window`, "rollback/window/invalid");
+  }
+  const persistent = r["persistent"];
+  if (persistent !== void 0 && typeof persistent !== "boolean") {
+    push(issues, `${rp}/persistent`, "rollback/persistent/invalid");
+  }
+}
+function checkOptString(v, p, max, code, issues) {
+  if (v === void 0) return;
+  if (typeof v !== "string" || v.length === 0 || v.length > max) {
+    push(issues, p, code);
+  }
+}
+function checkOptBool(v, p, code, issues) {
+  if (v === void 0) return;
+  if (typeof v !== "boolean") {
+    push(issues, p, code);
+  }
+}
+function checkEnum(v, p, set, code, issues) {
+  if (v === void 0) return;
+  if (typeof v !== "string" || !set.has(v)) {
+    push(issues, p, code);
+  }
+}
+function checkEnumArray(v, p, set, code, issues) {
+  if (!Array.isArray(v) || v.length === 0) {
+    push(issues, p, code);
+    return;
+  }
+  for (let i = 0; i < v.length; i++) {
+    const x = v[i];
+    if (typeof x !== "string" || !set.has(x)) {
+      push(issues, `${p}/${i}`, code);
+    }
+  }
+}
+function checkStringArray(v, p, code, issues) {
+  if (!Array.isArray(v) || v.length === 0) {
+    push(issues, p, code);
+    return;
+  }
+  for (let i = 0; i < v.length; i++) {
+    const x = v[i];
+    if (typeof x !== "string" || x.length === 0) {
+      push(issues, `${p}/${i}`, code);
+    }
+  }
+}
+var ISO_TAIL_RE = /T.*(?:Z|[+-]\d{2}:?\d{2})$/;
+function isValidIsoDate(s) {
+  if (s.length < 10) return false;
+  if (Number.isNaN(Date.parse(s))) return false;
+  return ISO_TAIL_RE.test(s);
+}
+function depthOf(value, current) {
+  if (value === null || typeof value !== "object") return current;
+  let m = current;
+  if (Array.isArray(value)) {
+    for (let i = 0; i < value.length; i++) {
+      const d = depthOf(value[i], current + 1);
+      if (d > m) m = d;
+    }
+    return m;
+  }
+  const obj = value;
+  const keys = Object.keys(obj);
+  for (let i = 0; i < keys.length; i++) {
+    const d = depthOf(obj[keys[i]], current + 1);
+    if (d > m) m = d;
+  }
+  return m;
+}
+function jp(parent, key) {
+  return `${parent}/${esc(key)}`;
+}
+function esc(s) {
+  return s.replace(/~/g, "~0").replace(/\//g, "~1");
+}
+function push(issues, path, code, message) {
+  issues.push({ path, code, message: message ?? code });
+}
+
+// src/assignment/hash.ts
+function hash32(input) {
+  let h = 2166136261;
+  for (let i = 0; i < input.length; i++) {
+    h ^= input.charCodeAt(i);
+    h = Math.imul(h, 16777619);
+  }
+  h ^= h >>> 16;
+  h = Math.imul(h, 2246822507);
+  h ^= h >>> 13;
+  h = Math.imul(h, 3266489909);
+  h ^= h >>> 16;
+  return h >>> 0;
+}
+function bucketUserId(userId) {
+  return hash32(userId) % 100;
+}
+
+// src/assignment/default.ts
+function assignDefault(experiment) {
+  return experiment.default;
+}
+
+// src/assignment/sticky-hash.ts
+function assignStickyHash(experiment, userId) {
+  const ids = experiment.variants.map((v) => v.id).sort();
+  const bucket = hash32(`${userId}:${experiment.id}`) % ids.length;
+  return ids[bucket] ?? experiment.default;
+}
+
+// src/assignment/random.ts
+function assignRandom(experiment, userId) {
+  return assignStickyHash(experiment, userId);
+}
+
+// src/assignment/weighted.ts
+function assignWeighted(experiment, userId) {
+  const split = experiment.split;
+  if (split === void 0) return experiment.default;
+  const ids = Object.keys(split).sort();
+  if (ids.length === 0) return experiment.default;
+  const bucket = hash32(`${userId}:${experiment.id}`) % 1e4;
+  let cumulative = 0;
+  for (const id of ids) {
+    cumulative += (split[id] ?? 0) * 100;
+    if (bucket < cumulative) return id;
+  }
+  return experiment.default;
+}
+
+// src/assignment/mutex.ts
+function resolveMutex(userId, mutexGroup, candidateIds) {
+  if (candidateIds.length === 0) return void 0;
+  const sorted = candidateIds.slice().sort();
+  const bucket = hash32(`${userId}:${mutexGroup}`) % sorted.length;
+  return sorted[bucket];
+}
+
+// src/assignment/index.ts
+function assignVariant(experiment, userId) {
+  const strategy = experiment.assignment ?? "default";
+  if (strategy === "default") return assignDefault(experiment);
+  if (userId === void 0 || userId === "") return assignDefault(experiment);
+  if (strategy === "random") return assignRandom(experiment, userId);
+  if (strategy === "sticky-hash") return assignStickyHash(experiment, userId);
+  if (strategy === "weighted") return assignWeighted(experiment, userId);
+  return assignDefault(experiment);
+}
+
+// src/history/ring-buffer.ts
+var RingBuffer = class {
+  constructor(capacity = 500) {
+    this.head = 0;
+    this.count = 0;
+    if (!Number.isInteger(capacity) || capacity < 1) {
+      throw new Error("RingBuffer capacity must be a positive integer");
+    }
+    this.capacity = capacity;
+    this.buffer = new Array(capacity);
+  }
+  push(item) {
+    this.buffer[this.head] = item;
+    this.head = (this.head + 1) % this.capacity;
+    if (this.count < this.capacity) this.count++;
+  }
+  toArray() {
+    const out = [];
+    const start = this.count < this.capacity ? 0 : this.head;
+    for (let i = 0; i < this.count; i++) {
+      const item = this.buffer[(start + i) % this.capacity];
+      if (item !== void 0) out.push(item);
+    }
+    return out;
+  }
+  clear() {
+    this.buffer = new Array(this.capacity);
+    this.head = 0;
+    this.count = 0;
+  }
+  get size() {
+    return this.count;
+  }
+};
+
+// src/targeting/operators/app-version.ts
+function matchAppVersion(range, ctxVersion) {
+  if (ctxVersion === void 0) return false;
+  return matchSemver(range, ctxVersion);
+}
+
+// src/targeting/operators/attributes.ts
+function matchAttributes(target, ctxAttrs) {
+  for (const k of Object.keys(target)) {
+    if (ctxAttrs === void 0 || ctxAttrs[k] !== target[k]) return false;
+  }
+  return true;
+}
+
+// src/targeting/operators/locale.ts
+function matchLocale(target, ctxLocale) {
+  if (ctxLocale === void 0) return false;
+  for (const t of target) {
+    if (ctxLocale === t || ctxLocale.startsWith(`${t}-`)) return true;
+  }
+  return false;
+}
+
+// src/targeting/operators/platform.ts
+function matchPlatform(target, ctxPlatform) {
+  return ctxPlatform !== void 0 && target.includes(ctxPlatform);
+}
+
+// src/targeting/operators/routes.ts
+function matchRoutes(target, ctxRoute) {
+  if (ctxRoute === void 0) return false;
+  for (let i = 0; i < target.length; i++) {
+    if (matchRoute(target[i], ctxRoute)) return true;
+  }
+  return false;
+}
+
+// src/targeting/operators/screen-size.ts
+function matchScreenSize(target, ctxSize) {
+  return ctxSize !== void 0 && target.includes(ctxSize);
+}
+
+// src/targeting/operators/user-id.ts
+function matchUserId(target, context) {
+  if ("mod" in target) {
+    const bucket = context.userIdBucket;
+    return typeof bucket === "number" && bucket < target.mod;
+  }
+  return context.userId !== void 0 && target.includes(context.userId);
+}
+
+// src/targeting/evaluator.ts
+function evaluate(targeting, context) {
+  const c = context;
+  if (targeting.platform !== void 0 && !matchPlatform(targeting.platform, c.platform))
+    return { matched: false, reason: "platform" };
+  if (targeting.screenSize !== void 0 && !matchScreenSize(targeting.screenSize, c.screenSize))
+    return { matched: false, reason: "screenSize" };
+  if (targeting.locale !== void 0 && !matchLocale(targeting.locale, c.locale))
+    return { matched: false, reason: "locale" };
+  if (targeting.appVersion !== void 0 && !matchAppVersion(targeting.appVersion, c.appVersion))
+    return { matched: false, reason: "appVersion" };
+  if (targeting.routes !== void 0 && !matchRoutes(targeting.routes, c.route))
+    return { matched: false, reason: "routes" };
+  if (targeting.attributes !== void 0 && !matchAttributes(targeting.attributes, c.attributes))
+    return { matched: false, reason: "attributes" };
+  if (targeting.userId !== void 0 && !matchUserId(targeting.userId, c))
+    return { matched: false, reason: "userId" };
+  if (targeting.predicate !== void 0 && !targeting.predicate(c))
+    return { matched: false, reason: "predicate" };
+  return { matched: true };
+}
+
+// src/engine/kill-switch.ts
+function isKilled(config, experiment) {
+  if (config.enabled === false) return true;
+  if (experiment.status === "archived") return true;
+  if (experiment.status === "draft") return true;
+  return false;
+}
+
+// src/engine/subscribe.ts
+var ListenerSet = class {
+  constructor() {
+    this.listeners = /* @__PURE__ */ new Set();
+  }
+  add(listener) {
+    this.listeners.add(listener);
+    return () => {
+      this.listeners.delete(listener);
+    };
+  }
+  emit(event) {
+    for (const listener of Array.from(this.listeners)) {
+      try {
+        listener(event);
+      } catch {
+      }
+    }
+  }
+  clear() {
+    this.listeners.clear();
+  }
+  get size() {
+    return this.listeners.size;
+  }
+};
+
+// src/engine/time-gate.ts
+function isTimeGated(experiment, now) {
+  if (experiment.startDate !== void 0) {
+    const t = Date.parse(experiment.startDate);
+    if (!Number.isFinite(t) || now < t) return true;
+  }
+  if (experiment.endDate !== void 0) {
+    const t = Date.parse(experiment.endDate);
+    if (!Number.isFinite(t) || now >= t) return true;
+  }
+  return false;
+}
+
+// src/engine/engine.ts
+var UnknownExperimentError = class extends Error {
+  constructor(experimentId) {
+    super(`Unknown experiment: ${experimentId}`);
+    this.name = "UnknownExperimentError";
+    this.experimentId = experimentId;
+  }
+};
+var VariantEngine = class {
+  constructor(config, options = {}) {
+    this.listeners = new ListenerSet();
+    this.overrides = /* @__PURE__ */ new Map();
+    this.cache = /* @__PURE__ */ new Map();
+    this.rolledBack = /* @__PURE__ */ new Set();
+    this.crashCounter = new CrashCounter();
+    this.disposed = false;
+    this.config = config;
+    this.experimentIndex = indexExperiments(config);
+    this.context = options.context ?? {};
+    this.evalContext = buildEvalContext(this.context);
+    this.failMode = options.failMode ?? "fail-open";
+    this.history = new RingBuffer(options.historySize ?? 500);
+    this.seedInitialAssignments(options.initialAssignments);
+    this.emit({ type: "ready", config });
+  }
+  /**
+   * Copy caller-supplied `{ experimentId: variantId }` pairs into the
+   * in-memory cache so the next `getVariant` call returns them without
+   * re-evaluating targeting. Invalid pairs are silently dropped — seeding
+   * is best-effort hydration, never a hard error.
+   */
+  seedInitialAssignments(seed) {
+    if (seed === void 0) return;
+    for (const experimentId of Object.keys(seed)) {
+      const variantId = seed[experimentId];
+      if (typeof variantId !== "string" || variantId.length === 0) continue;
+      const experiment = this.experimentIndex.get(experimentId);
+      if (experiment === void 0) continue;
+      if (!experiment.variants.some((v) => v.id === variantId)) continue;
+      this.cache.set(experimentId, variantId);
+    }
+  }
+  // ---------- resolution ---------------------------------------------------
+  getVariant(experimentId) {
+    if (this.disposed) {
+      return this.handleError(new Error("VariantEngine is disposed"), experimentId);
+    }
+    try {
+      const override = this.overrides.get(experimentId);
+      if (override !== void 0) return override;
+      const cached = this.cache.get(experimentId);
+      if (cached !== void 0) return cached;
+      const experiment = this.experimentIndex.get(experimentId);
+      if (experiment === void 0) {
+        if (this.failMode === "fail-closed") {
+          throw new UnknownExperimentError(experimentId);
+        }
+        return this.handleError(new UnknownExperimentError(experimentId), experimentId);
+      }
+      if (this.rolledBack.has(experimentId)) return experiment.default;
+      if (isKilled(this.config, experiment)) return experiment.default;
+      if (isTimeGated(experiment, Date.now())) return experiment.default;
+      if (!this.isTargeted(experiment)) return experiment.default;
+      if (experiment.mutex !== void 0) {
+        const winner = this.resolveMutexWinner(experiment.mutex);
+        if (winner !== experimentId) return experiment.default;
+      }
+      const variantId = assignVariant(experiment, this.context.userId);
+      this.cache.set(experimentId, variantId);
+      this.emit({ type: "assignment", experimentId, variantId, context: this.context });
+      return variantId;
+    } catch (err) {
+      if (this.failMode === "fail-closed") throw err;
+      return this.handleError(err, experimentId);
+    }
+  }
+  getVariantValue(experimentId) {
+    const variantId = this.getVariant(experimentId);
+    const experiment = this.experimentIndex.get(experimentId);
+    if (experiment === void 0) return void 0;
+    const variant = experiment.variants.find((v) => v.id === variantId);
+    return variant?.value ?? void 0;
+  }
+  // ---------- overrides ---------------------------------------------------
+  setVariant(experimentId, variantId, source = "user") {
+    if (this.disposed) return;
+    const experiment = this.experimentIndex.get(experimentId);
+    if (experiment === void 0) return;
+    if (!experiment.variants.some((v) => v.id === variantId)) return;
+    this.overrides.set(experimentId, variantId);
+    this.emit({ type: "variantChanged", experimentId, variantId, source });
+  }
+  clearVariant(experimentId) {
+    if (this.disposed) return;
+    if (!this.overrides.delete(experimentId)) return;
+    const experiment = this.experimentIndex.get(experimentId);
+    if (experiment === void 0) return;
+    const next = this.getVariant(experimentId);
+    this.emit({ type: "variantChanged", experimentId, variantId: next, source: "system" });
+  }
+  resetAll() {
+    if (this.disposed) return;
+    this.overrides.clear();
+    this.cache.clear();
+    this.rolledBack.clear();
+    for (const experiment of this.config.experiments) {
+      this.emit({
+        type: "variantChanged",
+        experimentId: experiment.id,
+        variantId: this.getVariant(experiment.id),
+        source: "system"
+      });
+    }
+  }
+  // ---------- lookup ------------------------------------------------------
+  /**
+   * Returns the currently loaded, deeply-frozen {@link ExperimentsConfig}.
+   *
+   * Exposed read-only so debug surfaces (e.g. `<VariantDebugOverlay />`)
+   * can display the raw config without reaching into private fields.
+   * Mutating this value has no effect on the engine.
+   */
+  getConfig() {
+    return this.config;
+  }
+  /**
+   * Returns a shallow copy of the current {@link VariantContext}.
+   *
+   * A copy is returned rather than the live object so callers can't
+   * accidentally mutate engine state. Use {@link updateContext} to
+   * change it.
+   */
+  getContext() {
+    return { ...this.context };
+  }
+  getExperiments(route) {
+    if (route === void 0) return this.config.experiments;
+    return this.config.experiments.filter((exp) => {
+      if (exp.routes === void 0) return true;
+      return exp.routes.some((pattern) => matchRoute(pattern, route));
+    });
+  }
+  // ---------- subscriptions ----------------------------------------------
+  subscribe(listener) {
+    return this.listeners.add(listener);
+  }
+  // ---------- mutation ----------------------------------------------------
+  updateContext(patch) {
+    if (this.disposed) return;
+    const merged = { ...this.context, ...patch };
+    this.context = merged;
+    this.evalContext = buildEvalContext(merged);
+    this.cache.clear();
+    this.emit({ type: "contextUpdated", context: merged });
+  }
+  async loadConfig(next) {
+    if (this.disposed) return;
+    const validated = validateConfig(next);
+    this.config = validated;
+    this.experimentIndex = indexExperiments(validated);
+    this.cache.clear();
+    this.rolledBack.clear();
+    this.crashCounter.clear();
+    this.emit({ type: "configLoaded", config: validated });
+  }
+  // ---------- crash rollback ---------------------------------------------
+  reportCrash(experimentId, _error) {
+    if (this.disposed) return;
+    const experiment = this.experimentIndex.get(experimentId);
+    if (experiment === void 0) return;
+    const rollback = experiment.rollback;
+    if (rollback === void 0) return;
+    const now = Date.now();
+    const count = this.crashCounter.record(experimentId, now, rollback.window);
+    if (count >= rollback.threshold) {
+      this.rolledBack.add(experimentId);
+      this.cache.delete(experimentId);
+      this.overrides.delete(experimentId);
+      this.emit({
+        type: "rollback",
+        experimentId,
+        variantId: experiment.default,
+        reason: `threshold ${rollback.threshold} crashes in ${rollback.window}ms`
+      });
+    }
+  }
+  // ---------- history -----------------------------------------------------
+  getHistory() {
+    return this.history.toArray();
+  }
+  // ---------- lifecycle ---------------------------------------------------
+  dispose() {
+    if (this.disposed) return;
+    this.disposed = true;
+    this.listeners.clear();
+    this.overrides.clear();
+    this.cache.clear();
+    this.rolledBack.clear();
+    this.crashCounter.clear();
+  }
+  // ---------- internals ---------------------------------------------------
+  isTargeted(experiment) {
+    if (experiment.targeting === void 0) return true;
+    return evaluate(experiment.targeting, this.evalContext).matched;
+  }
+  resolveMutexWinner(group) {
+    const userId = this.context.userId;
+    if (userId === void 0 || userId === "") return void 0;
+    const candidates = [];
+    const now = Date.now();
+    for (const exp of this.config.experiments) {
+      if (exp.mutex !== group) continue;
+      if (this.rolledBack.has(exp.id)) continue;
+      if (isKilled(this.config, exp)) continue;
+      if (isTimeGated(exp, now)) continue;
+      if (!this.isTargeted(exp)) continue;
+      candidates.push(exp.id);
+    }
+    return resolveMutex(userId, group, candidates);
+  }
+  emit(event) {
+    this.history.push(event);
+    this.listeners.emit(event);
+  }
+  handleError(error, experimentId) {
+    const experiment = this.experimentIndex.get(experimentId);
+    this.emit({ type: "error", error });
+    return experiment?.default ?? "";
+  }
+};
+function buildEvalContext(ctx) {
+  if (ctx.userId === void 0) return ctx;
+  return { ...ctx, userIdBucket: bucketUserId(ctx.userId) };
+}
+function indexExperiments(config) {
+  const map = /* @__PURE__ */ new Map();
+  for (const exp of config.experiments) map.set(exp.id, exp);
+  return map;
+}
+
+// src/engine/create.ts
+function createEngine(config, options = {}) {
+  return new VariantEngine(validateConfig(config), options);
+}
+
+exports.VariantEngine = VariantEngine;
+exports.createEngine = createEngine;
+//# sourceMappingURL=engine.cjs.map
+//# sourceMappingURL=engine.cjs.map