@guidelytech/flags 0.0.0-stage → 0.8.0

package/dist/cli.cjs

@@ -0,0 +1,2010 @@
+#!/usr/bin/env node
+"use strict";
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+
+// src/cli-main.ts
+var import_node_path2 = require("path");
+
+// src/hash.ts
+function utf8(input) {
+  const out = [];
+  for (let i = 0; i < input.length; i++) {
+    let c = input.charCodeAt(i);
+    if (c >= 55296 && c <= 56319 && i + 1 < input.length) {
+      const d = input.charCodeAt(i + 1);
+      if (d >= 56320 && d <= 57343) {
+        c = 65536 + (c - 55296 << 10) + (d - 56320);
+        i++;
+      }
+    }
+    if (c >= 55296 && c <= 57343) c = 65533;
+    if (c < 128) out.push(c);
+    else if (c < 2048) out.push(192 | c >> 6, 128 | c & 63);
+    else if (c < 65536) out.push(224 | c >> 12, 128 | c >> 6 & 63, 128 | c & 63);
+    else out.push(240 | c >> 18, 128 | c >> 12 & 63, 128 | c >> 6 & 63, 128 | c & 63);
+  }
+  return Uint8Array.from(out);
+}
+function decodeUtf8(bytes) {
+  if (typeof TextDecoder !== "undefined") return new TextDecoder().decode(bytes);
+  let s = "";
+  for (let i = 0; i < bytes.length; ) {
+    const b = bytes[i++];
+    let c;
+    if (b < 128) c = b;
+    else if (b < 224) c = (b & 31) << 6 | bytes[i++] & 63;
+    else if (b < 240) c = (b & 15) << 12 | (bytes[i++] & 63) << 6 | bytes[i++] & 63;
+    else c = (b & 7) << 18 | (bytes[i++] & 63) << 12 | (bytes[i++] & 63) << 6 | bytes[i++] & 63;
+    s += String.fromCodePoint(c);
+  }
+  return s;
+}
+function fnv1a32(bytes) {
+  let h = 2166136261;
+  for (let i = 0; i < bytes.length; i++) {
+    h ^= bytes[i];
+    h = Math.imul(h, 16777619) >>> 0;
+  }
+  return h >>> 0;
+}
+function hashBucket(seed, value) {
+  const inner = fnv1a32(utf8(seed + value));
+  return fnv1a32(utf8(String(inner))) % 1e4 / 1e4;
+}
+var K = new Uint32Array([
+  1116352408,
+  1899447441,
+  3049323471,
+  3921009573,
+  961987163,
+  1508970993,
+  2453635748,
+  2870763221,
+  3624381080,
+  310598401,
+  607225278,
+  1426881987,
+  1925078388,
+  2162078206,
+  2614888103,
+  3248222580,
+  3835390401,
+  4022224774,
+  264347078,
+  604807628,
+  770255983,
+  1249150122,
+  1555081692,
+  1996064986,
+  2554220882,
+  2821834349,
+  2952996808,
+  3210313671,
+  3336571891,
+  3584528711,
+  113926993,
+  338241895,
+  666307205,
+  773529912,
+  1294757372,
+  1396182291,
+  1695183700,
+  1986661051,
+  2177026350,
+  2456956037,
+  2730485921,
+  2820302411,
+  3259730800,
+  3345764771,
+  3516065817,
+  3600352804,
+  4094571909,
+  275423344,
+  430227734,
+  506948616,
+  659060556,
+  883997877,
+  958139571,
+  1322822218,
+  1537002063,
+  1747873779,
+  1955562222,
+  2024104815,
+  2227730452,
+  2361852424,
+  2428436474,
+  2756734187,
+  3204031479,
+  3329325298
+]);
+function sha256Hex(input) {
+  const msg = typeof input === "string" ? utf8(input) : input;
+  const bitLen = msg.length * 8;
+  const padded = new Uint8Array(msg.length + 9 + 63 >> 6 << 6);
+  padded.set(msg);
+  padded[msg.length] = 128;
+  const view = new DataView(padded.buffer);
+  view.setUint32(padded.length - 8, Math.floor(bitLen / 4294967296));
+  view.setUint32(padded.length - 4, bitLen >>> 0);
+  const h = new Uint32Array([1779033703, 3144134277, 1013904242, 2773480762, 1359893119, 2600822924, 528734635, 1541459225]);
+  const w = new Uint32Array(64);
+  for (let off = 0; off < padded.length; off += 64) {
+    for (let i = 0; i < 16; i++) w[i] = view.getUint32(off + i * 4);
+    for (let i = 16; i < 64; i++) {
+      const a2 = w[i - 15], b2 = w[i - 2];
+      const s0 = (a2 >>> 7 | a2 << 25) ^ (a2 >>> 18 | a2 << 14) ^ a2 >>> 3;
+      const s1 = (b2 >>> 17 | b2 << 15) ^ (b2 >>> 19 | b2 << 13) ^ b2 >>> 10;
+      w[i] = w[i - 16] + s0 + w[i - 7] + s1 >>> 0;
+    }
+    let a = h[0], b = h[1], c = h[2], d = h[3], e = h[4], f = h[5], g = h[6], hh = h[7];
+    for (let i = 0; i < 64; i++) {
+      const S1 = (e >>> 6 | e << 26) ^ (e >>> 11 | e << 21) ^ (e >>> 25 | e << 7);
+      const ch = e & f ^ ~e & g;
+      const t1 = hh + S1 + ch + K[i] + w[i] >>> 0;
+      const S0 = (a >>> 2 | a << 30) ^ (a >>> 13 | a << 19) ^ (a >>> 22 | a << 10);
+      const maj = a & b ^ a & c ^ b & c;
+      const t2 = S0 + maj >>> 0;
+      hh = g;
+      g = f;
+      f = e;
+      e = d + t1 >>> 0;
+      d = c;
+      c = b;
+      b = a;
+      a = t1 + t2 >>> 0;
+    }
+    h[0] = h[0] + a >>> 0;
+    h[1] = h[1] + b >>> 0;
+    h[2] = h[2] + c >>> 0;
+    h[3] = h[3] + d >>> 0;
+    h[4] = h[4] + e >>> 0;
+    h[5] = h[5] + f >>> 0;
+    h[6] = h[6] + g >>> 0;
+    h[7] = h[7] + hh >>> 0;
+  }
+  let hex = "";
+  for (let i = 0; i < 8; i++) hex += h[i].toString(16).padStart(8, "0");
+  return hex;
+}
+function hashConfidential(salt, value) {
+  if (typeof value === "string") return sha256Hex(salt + value);
+  const s = utf8(salt);
+  const joined = new Uint8Array(s.length + value.length);
+  joined.set(s);
+  joined.set(value, s.length);
+  return sha256Hex(joined);
+}
+
+// src/crypto.ts
+var ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+function base64ToBytes(input) {
+  const s = input.trim().replace(/-/g, "+").replace(/_/g, "/").replace(/=+$/, "");
+  const out = new Uint8Array(Math.floor(s.length * 3 / 4));
+  let buffer = 0;
+  let bits = 0;
+  let n = 0;
+  for (let i = 0; i < s.length; i++) {
+    const v = ALPHABET.indexOf(s[i]);
+    if (v < 0) throw new Error("invalid base64");
+    buffer = buffer << 6 | v;
+    bits += 6;
+    if (bits >= 8) {
+      bits -= 8;
+      out[n++] = buffer >> bits & 255;
+    }
+  }
+  return out.subarray(0, n);
+}
+async function decryptPayloadString(encrypted, decryptionKey) {
+  const subtle = globalThis.crypto?.subtle;
+  if (!subtle) throw new Error("WebCrypto (crypto.subtle) is not available in this runtime; encrypted payloads need it (Node \u2265 19, browsers, edge runtimes, or a polyfill)");
+  const [ivText, dataText] = encrypted.split(".");
+  if (!ivText || !dataText) throw new Error("malformed encrypted payload");
+  const key = base64ToBytes(decryptionKey);
+  if (key.length !== 32) throw new Error("decryptionKey must be base64 of 32 bytes");
+  const cryptoKey = await subtle.importKey("raw", key, { name: "AES-GCM" }, false, ["decrypt"]);
+  const plain = await subtle.decrypt({ name: "AES-GCM", iv: base64ToBytes(ivText) }, cryptoKey, base64ToBytes(dataText));
+  return decodeUtf8(new Uint8Array(plain));
+}
+
+// src/util.ts
+function stableStringify(value) {
+  if (value === null || typeof value !== "object") return JSON.stringify(value) ?? "null";
+  if (Array.isArray(value)) return `[${value.map((v) => v === void 0 ? "null" : stableStringify(v)).join(",")}]`;
+  if (value instanceof Date) return JSON.stringify(value.toISOString());
+  const obj = value;
+  return `{${Object.keys(obj).filter((k) => obj[k] !== void 0).sort().map((k) => `${JSON.stringify(k)}:${stableStringify(obj[k])}`).join(",")}}`;
+}
+function isEncryptedPayload(x) {
+  return !!x && typeof x === "object" && typeof x.encryptedPayload === "string";
+}
+function isRemoteResults(x) {
+  return !!x && typeof x === "object" && !("schemaVersion" in x) && !!x.flags && typeof x.flags === "object";
+}
+function isFlagsPayload(x) {
+  return !!x && typeof x === "object" && "schemaVersion" in x && !!x.flags && typeof x.flags === "object";
+}
+function kindOf(v) {
+  if (v === null || v === void 0) return "null";
+  if (Array.isArray(v)) return "array";
+  return typeof v;
+}
+function compact(attrs) {
+  const out = {};
+  for (const [k, v] of Object.entries(attrs)) if (v !== void 0) out[k] = v;
+  return out;
+}
+function parseUrlOverrides(search, param = "guidely_flags") {
+  let raw = null;
+  try {
+    raw = new URLSearchParams(search.startsWith("?") ? search.slice(1) : search).get(param);
+  } catch {
+    return {};
+  }
+  return raw && parseOverrides(raw) || {};
+}
+function parseOverrides(text) {
+  const raw = text.trim();
+  if (raw.startsWith("{")) {
+    try {
+      const obj = JSON.parse(raw);
+      return obj && typeof obj === "object" && !Array.isArray(obj) ? obj : null;
+    } catch {
+      return null;
+    }
+  }
+  const out = {};
+  const items = [];
+  let depth = 0;
+  let quoted = false;
+  let start = 0;
+  for (let i = 0; i < raw.length; i++) {
+    const c = raw[i];
+    if (quoted) {
+      if (c === "\\") i++;
+      else if (c === '"') quoted = false;
+    } else if (c === '"') quoted = true;
+    else if (c === "[" || c === "{") depth++;
+    else if (c === "]" || c === "}") depth = Math.max(0, depth - 1);
+    else if ((c === "," || c === "\n") && depth === 0) {
+      items.push(raw.slice(start, i));
+      start = i + 1;
+    }
+  }
+  items.push(raw.slice(start));
+  for (const item of items) {
+    const sep2 = item.indexOf(":");
+    if (sep2 <= 0) continue;
+    const key = item.slice(0, sep2).trim();
+    const text2 = item.slice(sep2 + 1).trim();
+    if (!key) continue;
+    try {
+      out[key] = JSON.parse(text2);
+    } catch {
+      out[key] = text2;
+    }
+  }
+  return out;
+}
+function isDev() {
+  try {
+    const p = globalThis.process;
+    return !!p?.env && p.env.NODE_ENV !== "production";
+  } catch {
+    return false;
+  }
+}
+function timer(fn, ms) {
+  const t = setTimeout(fn, ms);
+  t.unref?.();
+  return t;
+}
+
+// src/dev-overrides.ts
+var OVERRIDES_ENV = "GUIDELY_FLAG_OVERRIDES";
+var OVERRIDES_FILE_ENV = "GUIDELY_FLAG_OVERRIDES_FILE";
+var OVERRIDE_BEHAVIOUR_ENV = "GUIDELY_FLAG_OVERRIDE_BEHAVIOUR";
+var OVERRIDES_GLOBAL = "__GUIDELY_FLAG_OVERRIDES__";
+var OVERRIDE_BEHAVIOUR_GLOBAL = "__GUIDELY_FLAG_OVERRIDE_BEHAVIOUR__";
+var BEHAVIOURS = ["localOnly", "localOverRemote", "remoteOverLocal"];
+var runtime = () => globalThis;
+function env(name) {
+  const g = runtime();
+  try {
+    const v = g.process?.env?.[name];
+    if (v !== void 0) return v;
+  } catch {
+  }
+  try {
+    return g.Deno?.env?.get(name);
+  } catch {
+    return void 0;
+  }
+}
+function readFile(path) {
+  const g = runtime();
+  const fs = g.process?.getBuiltinModule?.("node:fs");
+  if (fs) return fs.readFileSync(path, "utf8");
+  if (g.Deno?.readTextFileSync) return g.Deno.readTextFileSync(path);
+  throw new Error("this runtime cannot read files");
+}
+function behaviourOf(raw, source, out) {
+  if (typeof raw !== "string" || !raw.trim()) return;
+  const b = raw.trim();
+  if (BEHAVIOURS.includes(b)) {
+    out.behaviour = b;
+    out.sources.push(source);
+  } else out.errors.push(`${source} must be localOnly, localOverRemote or remoteOverLocal (got "${raw}"); ignoring it.`);
+}
+function merge(text, source, out) {
+  if (text === void 0 || !text.trim()) return;
+  const values = parseOverrides(text);
+  if (!values) return void out.errors.push(`${source} is not a JSON object or a key:value list; ignoring it.`);
+  if (!Object.keys(values).length) return;
+  Object.assign(out.values, values);
+  out.sources.push(source);
+}
+function readDevOverrides() {
+  const out = { values: {}, sources: [], errors: [] };
+  const file = env(OVERRIDES_FILE_ENV);
+  if (file?.trim()) {
+    try {
+      merge(readFile(file.trim()), `${OVERRIDES_FILE_ENV} (${file.trim()})`, out);
+    } catch (err) {
+      out.errors.push(`Could not read ${OVERRIDES_FILE_ENV} (${file.trim()}): ${err instanceof Error ? err.message : String(err)}; ignoring it.`);
+    }
+  }
+  merge(env(OVERRIDES_ENV), OVERRIDES_ENV, out);
+  const g = runtime()[OVERRIDES_GLOBAL];
+  if (g && typeof g === "object" && !Array.isArray(g)) {
+    if (Object.keys(g).length) {
+      Object.assign(out.values, g);
+      out.sources.push(OVERRIDES_GLOBAL);
+    }
+  } else if (typeof g === "string") merge(g, OVERRIDES_GLOBAL, out);
+  else if (g !== void 0 && g !== null) out.errors.push(`${OVERRIDES_GLOBAL} must be an object or overrides text; ignoring it.`);
+  behaviourOf(env(OVERRIDE_BEHAVIOUR_ENV), OVERRIDE_BEHAVIOUR_ENV, out);
+  behaviourOf(runtime()[OVERRIDE_BEHAVIOUR_GLOBAL], OVERRIDE_BEHAVIOUR_GLOBAL, out);
+  return out;
+}
+
+// src/values.ts
+function textOf(v) {
+  if (typeof v === "string") return v;
+  if (typeof v === "boolean") return v ? "true" : "false";
+  if (typeof v === "number") {
+    if (!Number.isFinite(v)) return void 0;
+    if (Number.isInteger(v) && Math.abs(v) < 1e21) return v.toFixed(0);
+    return String(v);
+  }
+  if (typeof v === "bigint") return v.toString();
+  return void 0;
+}
+var NUMERIC = /^[+-]?(\d+\.?\d*|\.\d+)([eE][+-]?\d+)?$/;
+function numberOf(v) {
+  if (typeof v === "number") return Number.isFinite(v) ? v : void 0;
+  if (typeof v === "string") {
+    const s = v.trim();
+    if (!NUMERIC.test(s)) return void 0;
+    const n = Number(s);
+    return Number.isFinite(n) ? n : void 0;
+  }
+  return void 0;
+}
+function arrayOf(v) {
+  if (Array.isArray(v)) return v;
+  if (typeof v === "string") {
+    const s = v.trim();
+    if (!s.startsWith("[")) return void 0;
+    try {
+      const parsed = JSON.parse(s);
+      return Array.isArray(parsed) ? parsed : void 0;
+    } catch {
+      return void 0;
+    }
+  }
+  return void 0;
+}
+var SEMVER = /^[vV]?(\d+)(?:\.(\d+))?(?:\.(\d+))?(?:-([0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*))?(?:\+[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?$/;
+function parseSemver(v) {
+  const s = typeof v === "number" ? textOf(v) : typeof v === "string" ? v.trim() : void 0;
+  if (s === void 0) return void 0;
+  const m = SEMVER.exec(s);
+  if (!m) return void 0;
+  return { major: Number(m[1]), minor: Number(m[2] ?? 0), patch: Number(m[3] ?? 0), pre: m[4] ? m[4].split(".") : [] };
+}
+function cmp(a, b) {
+  return a < b ? -1 : a > b ? 1 : 0;
+}
+function compareSemver(a, b) {
+  const c = cmp(a.major, b.major) || cmp(a.minor, b.minor) || cmp(a.patch, b.patch);
+  if (c) return c;
+  if (!a.pre.length || !b.pre.length) return a.pre.length ? -1 : b.pre.length ? 1 : 0;
+  for (let i = 0; i < Math.max(a.pre.length, b.pre.length); i++) {
+    const x = a.pre[i], y = b.pre[i];
+    if (x === void 0) return -1;
+    if (y === void 0) return 1;
+    const xn = /^\d+$/.test(x), yn = /^\d+$/.test(y);
+    if (xn && yn) {
+      const d = cmp(Number(x), Number(y));
+      if (d) return d;
+    } else if (xn) return -1;
+    else if (yn) return 1;
+    else if (x !== y) return x < y ? -1 : 1;
+  }
+  return 0;
+}
+function daysInMonth(year, month) {
+  if (month === 2) return year % 4 === 0 && year % 100 !== 0 || year % 400 === 0 ? 29 : 28;
+  return [4, 6, 9, 11].includes(month) ? 30 : 31;
+}
+function daysFromCivil(year, month, day) {
+  const y = month <= 2 ? year - 1 : year;
+  const era = Math.floor(y / 400);
+  const yoe = y - era * 400;
+  const doy = Math.floor((153 * (month + (month > 2 ? -3 : 9)) + 2) / 5) + day - 1;
+  const doe = yoe * 365 + Math.floor(yoe / 4) - Math.floor(yoe / 100) + doy;
+  return era * 146097 + doe - 719468;
+}
+var ISO = /^(\d{4})-(\d{2})-(\d{2})(?:[Tt ](\d{2}):(\d{2})(?::(\d{2})(?:\.(\d+))?)?(Z|z|[+-]\d{2}:\d{2})?)?$/;
+function instantOf(v) {
+  if (v instanceof Date) return Number.isNaN(v.getTime()) ? void 0 : v.getTime();
+  if (typeof v === "number") return Number.isFinite(v) ? v * 1e3 : void 0;
+  if (typeof v !== "string") return void 0;
+  const m = ISO.exec(v.trim());
+  if (!m) return void 0;
+  const [, y, mo, d, h = "0", mi = "0", s = "0", frac, tz] = m;
+  const month = Number(mo), day = Number(d), hour = Number(h), minute = Number(mi), second = Number(s);
+  const year = Number(y);
+  if (month < 1 || month > 12 || day < 1 || day > daysInMonth(year, month) || hour > 23 || minute > 59 || second > 59) return void 0;
+  let ms = (daysFromCivil(year, month, day) * 86400 + hour * 3600 + minute * 60 + second) * 1e3 + (frac ? Math.floor(Number(`0.${frac}`) * 1e3) : 0);
+  if (tz && tz !== "Z" && tz !== "z") {
+    const sign = tz[0] === "-" ? -1 : 1;
+    ms -= sign * (Number(tz.slice(1, 3)) * 60 + Number(tz.slice(4, 6))) * 6e4;
+  }
+  return ms;
+}
+function jsonEquals(a, b) {
+  if (a === b) return true;
+  if (a === null || b === null || a === void 0 || b === void 0) return (a ?? null) === (b ?? null);
+  if (typeof a === "number" && typeof b === "number") return a === b;
+  if (Array.isArray(a)) return Array.isArray(b) && a.length === b.length && a.every((x, i) => jsonEquals(x, b[i]));
+  if (typeof a === "object" && typeof b === "object" && !Array.isArray(b)) {
+    const ka = Object.keys(a).filter((k) => a[k] !== void 0);
+    const kb = Object.keys(b).filter((k) => b[k] !== void 0);
+    return ka.length === kb.length && ka.every((k) => Object.prototype.hasOwnProperty.call(b, k) && jsonEquals(a[k], b[k]));
+  }
+  return false;
+}
+function isOn(v) {
+  return !(v === null || v === void 0 || v === false || v === 0 || v === "");
+}
+function jsonTypeOf(v) {
+  if (v === null || v === void 0) return void 0;
+  if (Array.isArray(v)) return "array";
+  if (typeof v === "object") return "object";
+  if (typeof v === "string" || typeof v === "number" || typeof v === "boolean") return typeof v;
+  return void 0;
+}
+
+// src/evaluate.ts
+var MAX_DEPTH = 32;
+var CycleError = class extends Error {
+};
+function nowOf(now) {
+  if (now === void 0) return Date.now();
+  if (typeof now === "number") return now;
+  if (now instanceof Date) return now.getTime();
+  return instantOf(now) ?? Date.now();
+}
+function lookupAttribute(attributes, name) {
+  if (Object.prototype.hasOwnProperty.call(attributes, name)) return attributes[name] ?? void 0;
+  if (!name.includes(".")) return void 0;
+  let cur = attributes;
+  for (const part of name.split(".")) {
+    if (cur && typeof cur === "object" && !Array.isArray(cur) && Object.prototype.hasOwnProperty.call(cur, part)) cur = cur[part];
+    else return void 0;
+  }
+  return cur ?? void 0;
+}
+function hashValueOf(attributes, name) {
+  const t = textOf(lookupAttribute(attributes, name));
+  return t === void 0 || t === "" ? void 0 : t;
+}
+function isScheduleActive(schedule, now) {
+  if (!schedule) return true;
+  if (schedule.start) {
+    const start = instantOf(schedule.start);
+    if (start === void 0 || now < start) return false;
+  }
+  if (schedule.end) {
+    const end = instantOf(schedule.end);
+    if (end === void 0 || now >= end) return false;
+  }
+  return true;
+}
+function clamp01(n) {
+  return typeof n === "number" && Number.isFinite(n) ? Math.min(1, Math.max(0, n)) : 0;
+}
+function effectiveCoverage(rule, now) {
+  let coverage = clamp01(rule.coverage);
+  let latest = -Infinity;
+  for (const step of rule.ramp ?? []) {
+    const at = instantOf(step.at);
+    if (at !== void 0 && at <= now && at >= latest) {
+      latest = at;
+      coverage = clamp01(step.coverage);
+    }
+  }
+  return coverage;
+}
+var regexCache = /* @__PURE__ */ new Map();
+function compile(pattern, ci) {
+  const k = `${ci ? "i" : "-"}:${pattern}`;
+  let re = regexCache.get(k);
+  if (re === void 0) {
+    try {
+      re = new RegExp(pattern, ci ? "i" : "");
+    } catch {
+      re = null;
+    }
+    if (regexCache.size > 500) regexCache.clear();
+    regexCache.set(k, re);
+  }
+  return re;
+}
+function lower(s, ci) {
+  return ci ? s.toLowerCase() : s;
+}
+function textValues(values, ci) {
+  const out = [];
+  for (const v of values) {
+    const t = textOf(v);
+    if (t !== void 0) out.push(lower(t, ci));
+  }
+  return out;
+}
+function affixMatches(salt, text, values, suffix) {
+  const bytes = utf8(text);
+  return values.some((v) => {
+    if (typeof v !== "string") return false;
+    const sep2 = v.indexOf("_");
+    if (sep2 <= 0) return false;
+    const n = Number(v.slice(0, sep2));
+    if (!Number.isInteger(n) || n < 0 || n > bytes.length) return false;
+    const part = suffix ? bytes.slice(bytes.length - n) : bytes.slice(0, n);
+    return hashConfidential(salt, part) === v.slice(sep2 + 1);
+  });
+}
+function evalAttribute(ctx, c) {
+  const raw = lookupAttribute(ctx.attributes, c.attribute);
+  const values = Array.isArray(c.values) ? c.values : [];
+  const op = c.operator;
+  if (op === "notExists") return raw === void 0;
+  if (raw === void 0) return false;
+  const ci = c.caseInsensitive;
+  switch (op) {
+    case "exists":
+      return true;
+    case "isType":
+      return jsonTypeOf(raw) === values[0];
+    case "isTrue":
+      return raw === true || typeof raw === "string" && raw.toLowerCase() === "true";
+    case "isFalse":
+      return raw === false || typeof raw === "string" && raw.toLowerCase() === "false";
+    case "equals":
+    case "notEquals":
+    case "in":
+    case "notIn":
+    case "contains":
+    case "notContains":
+    case "startsWith":
+    case "notStartsWith":
+    case "endsWith":
+    case "notEndsWith": {
+      const t0 = textOf(raw);
+      if (t0 === void 0) return false;
+      const t = lower(t0, ci);
+      const vs = textValues(values, ci);
+      switch (op) {
+        case "equals":
+          return vs.length > 0 && t === vs[0];
+        case "notEquals":
+          return vs.length > 0 && t !== vs[0];
+        case "in":
+          return vs.includes(t);
+        case "notIn":
+          return !vs.includes(t);
+        case "contains":
+          return vs.some((v) => t.includes(v));
+        case "notContains":
+          return !vs.some((v) => t.includes(v));
+        case "startsWith":
+          return vs.some((v) => t.startsWith(v));
+        case "notStartsWith":
+          return !vs.some((v) => t.startsWith(v));
+        case "endsWith":
+          return vs.some((v) => t.endsWith(v));
+        default:
+          return !vs.some((v) => t.endsWith(v));
+      }
+    }
+    case "regex":
+    case "notRegex": {
+      const t = textOf(raw);
+      if (t === void 0) return false;
+      const res = [];
+      for (const v of values) {
+        const re = typeof v === "string" ? compile(v, !!ci) : null;
+        if (!re) return false;
+        res.push(re);
+      }
+      const any = res.some((re) => re.test(t));
+      return op === "regex" ? any : !any;
+    }
+    case "numEquals":
+    case "numNotEquals":
+    case "gt":
+    case "gte":
+    case "lt":
+    case "lte": {
+      const a = numberOf(raw);
+      const b = numberOf(values[0]);
+      if (a === void 0 || b === void 0) return false;
+      if (op === "numEquals") return a === b;
+      if (op === "numNotEquals") return a !== b;
+      if (op === "gt") return a > b;
+      if (op === "gte") return a >= b;
+      if (op === "lt") return a < b;
+      return a <= b;
+    }
+    case "semverEquals":
+    case "semverNotEquals":
+    case "semverGt":
+    case "semverGte":
+    case "semverLt":
+    case "semverLte":
+    case "semverIn":
+    case "semverNotIn": {
+      const a = parseSemver(raw);
+      if (!a) return false;
+      const bs = values.map(parseSemver);
+      if (bs.some((b) => !b)) return false;
+      if (op === "semverIn") return bs.some((b) => compareSemver(a, b) === 0);
+      if (op === "semverNotIn") return !bs.some((b) => compareSemver(a, b) === 0);
+      if (!bs[0]) return false;
+      const d = compareSemver(a, bs[0]);
+      if (op === "semverEquals") return d === 0;
+      if (op === "semverNotEquals") return d !== 0;
+      if (op === "semverGt") return d > 0;
+      if (op === "semverGte") return d >= 0;
+      if (op === "semverLt") return d < 0;
+      return d <= 0;
+    }
+    case "before":
+    case "after": {
+      const a = instantOf(raw);
+      const b = instantOf(values[0]);
+      if (a === void 0 || b === void 0) return false;
+      return op === "before" ? a < b : a > b;
+    }
+    case "arrayContainsAny":
+    case "arrayNotContainsAny":
+    case "arrayContainsAll": {
+      const arr = arrayOf(raw);
+      if (!arr) return false;
+      const elems = textValues(arr, ci);
+      const vs = textValues(values, ci);
+      if (op === "arrayContainsAll") return vs.every((v) => elems.includes(v));
+      const any = vs.some((v) => elems.includes(v));
+      return op === "arrayContainsAny" ? any : !any;
+    }
+    case "equalsHashed":
+    case "notEqualsHashed":
+    case "inHashed":
+    case "notInHashed":
+    case "startsWithHashed":
+    case "notStartsWithHashed":
+    case "endsWithHashed":
+    case "notEndsWithHashed": {
+      const t = textOf(raw);
+      if (t === void 0) return false;
+      const salt = ctx.payload.salt ?? "";
+      if (op === "startsWithHashed" || op === "notStartsWithHashed" || op === "endsWithHashed" || op === "notEndsWithHashed") {
+        const any = affixMatches(salt, t, values, op === "endsWithHashed" || op === "notEndsWithHashed");
+        return op.startsWith("not") ? !any : any;
+      }
+      const h = hashConfidential(salt, t);
+      if (op === "equalsHashed") return typeof values[0] === "string" && h === values[0];
+      if (op === "notEqualsHashed") return typeof values[0] === "string" && h !== values[0];
+      if (op === "inHashed") return values.includes(h);
+      return !values.includes(h);
+    }
+    case "arrayContainsAnyHashed":
+    case "arrayNotContainsAnyHashed": {
+      const arr = arrayOf(raw);
+      if (!arr) return false;
+      const salt = ctx.payload.salt ?? "";
+      const any = arr.some((e) => {
+        const t = textOf(e);
+        return t !== void 0 && values.includes(hashConfidential(salt, t));
+      });
+      return op === "arrayContainsAnyHashed" ? any : !any;
+    }
+    default:
+      return false;
+  }
+}
+function enter(ctx, frame, fn) {
+  if (ctx.stack.includes(frame)) throw new CycleError(`Cycle detected: ${[...ctx.stack, frame].join(" \u2192 ")}`);
+  if (ctx.stack.length >= MAX_DEPTH) throw new CycleError(`Flag references nest deeper than ${MAX_DEPTH} levels: ${ctx.stack.join(" \u2192 ")}`);
+  ctx.stack.push(frame);
+  try {
+    return fn();
+  } finally {
+    ctx.stack.pop();
+  }
+}
+function segmentMatches(ctx, key) {
+  const seg = ctx.payload.segments?.[key];
+  if (!seg) return void 0;
+  return enter(ctx, `segment:${key}`, () => {
+    if (seg.kind === "list") {
+      const t = textOf(lookupAttribute(ctx.attributes, seg.attribute));
+      if (t === void 0) return false;
+      const needle = seg.hashed ? hashConfidential(ctx.payload.salt ?? "", t) : t;
+      return Array.isArray(seg.values) && seg.values.includes(needle);
+    }
+    if (seg.kind === "conditions") return allMatch(ctx, seg.conditions);
+    return false;
+  });
+}
+function compareFlag(op, actual, expected) {
+  switch (op) {
+    case "isOn":
+      return isOn(actual);
+    case "isOff":
+      return !isOn(actual);
+    case "equals":
+      return jsonEquals(actual, expected ?? null);
+    case "notEquals":
+      return !jsonEquals(actual, expected ?? null);
+    default:
+      return false;
+  }
+}
+function referencedValue(ctx, key) {
+  const res = evalFlag(ctx, key);
+  return res.reason === "FLAG_NOT_FOUND" ? void 0 : { value: res.value };
+}
+function conditionMatches(ctx, c) {
+  if (!c || typeof c !== "object") return false;
+  switch (c.kind) {
+    case "attribute":
+      return evalAttribute(ctx, c);
+    case "segment": {
+      const m = segmentMatches(ctx, c.segment);
+      if (m === void 0) return false;
+      if (c.operator === "in") return m;
+      if (c.operator === "notIn") return !m;
+      return false;
+    }
+    case "flag": {
+      const ref = referencedValue(ctx, c.flag);
+      return ref ? compareFlag(c.operator, ref.value, c.value) : false;
+    }
+    case "group": {
+      const list = Array.isArray(c.conditions) ? c.conditions : [];
+      let r;
+      if (c.op === "and") r = allMatch(ctx, list);
+      else if (c.op === "or") r = list.some((x) => conditionMatches(ctx, x));
+      else return false;
+      return c.negate ? !r : r;
+    }
+    default:
+      return false;
+  }
+}
+function allMatch(ctx, conditions) {
+  if (!conditions) return true;
+  for (const c of conditions) if (!conditionMatches(ctx, c)) return false;
+  return true;
+}
+function base(flag, value, reason) {
+  return { key: flag.key, value: value === void 0 ? null : value, reason, inExperiment: false };
+}
+function stickyDocKey(attribute, value) {
+  return `${attribute}||${value}`;
+}
+function runExperiment(ctx, flag, rule) {
+  const variations = Array.isArray(rule.variations) ? rule.variations : [];
+  if (!variations.length) return void 0;
+  let hashAttribute = rule.hashAttribute;
+  let hv = hashValueOf(ctx.attributes, rule.hashAttribute);
+  const fallbackValue = rule.fallbackAttribute ? hashValueOf(ctx.attributes, rule.fallbackAttribute) : void 0;
+  if (hv === void 0 && rule.fallbackAttribute && fallbackValue !== void 0) {
+    hashAttribute = rule.fallbackAttribute;
+    hv = fallbackValue;
+  }
+  if (hv === void 0) return void 0;
+  const bucketVersion = rule.bucketVersion ?? 0;
+  const useSticky = !!ctx.sticky && !rule.disableStickyBucketing;
+  let index = -1;
+  const bucket = hashBucket(rule.seed, hv);
+  let stickyUsed = false;
+  if (useSticky) {
+    const merged = {};
+    if (rule.fallbackAttribute && fallbackValue !== void 0) Object.assign(merged, ctx.sticky.get(stickyDocKey(rule.fallbackAttribute, fallbackValue)) ?? {});
+    const primary = hashValueOf(ctx.attributes, rule.hashAttribute);
+    if (primary !== void 0) Object.assign(merged, ctx.sticky.get(stickyDocKey(rule.hashAttribute, primary)) ?? {});
+    const prefix = `${rule.key}__`;
+    const minVersion = rule.minBucketVersion ?? 0;
+    for (const k of Object.keys(merged)) {
+      if (!k.startsWith(prefix)) continue;
+      const v = Number(k.slice(prefix.length));
+      if (Number.isInteger(v) && v < minVersion) return void 0;
+    }
+    const assigned = merged[`${prefix}${bucketVersion}`];
+    if (assigned !== void 0) {
+      const i = variations.findIndex((v) => v.id === assigned);
+      if (i >= 0) {
+        index = i;
+        stickyUsed = true;
+      }
+    }
+  }
+  if (index < 0) {
+    if (rule.namespace) {
+      const n = hashBucket(`__${rule.namespace.id}`, hv);
+      if (!(n >= rule.namespace.start && n < rule.namespace.end)) return void 0;
+    }
+    const coverage = clamp01(rule.coverage);
+    let cum = 0;
+    for (let i = 0; i < variations.length; i++) {
+      const w = Math.max(0, Number(variations[i].weight) || 0);
+      const start = cum;
+      const end = cum + coverage * w;
+      cum += w;
+      if (bucket >= start && bucket < end) {
+        index = i;
+        break;
+      }
+    }
+    if (index < 0) return void 0;
+    if (useSticky) {
+      const docKey = stickyDocKey(hashAttribute, hv);
+      const doc = { ...ctx.sticky.get(docKey) ?? {} };
+      doc[`${rule.key}__${bucketVersion}`] = variations[index].id;
+      ctx.sticky.set(docKey, doc);
+    }
+  }
+  const variation = variations[index];
+  return {
+    key: flag.key,
+    value: variation.value === void 0 ? null : variation.value,
+    reason: "EXPERIMENT",
+    ruleId: rule.id,
+    variationId: variation.id,
+    inExperiment: true,
+    experiment: { key: rule.key, name: rule.name, variationId: variation.id, variationName: variation.name, variationIndex: index, hashAttribute, hashValue: hv, bucket, stickyBucketUsed: stickyUsed }
+  };
+}
+function applyRule(ctx, flag, rule) {
+  switch (rule.type) {
+    case "force":
+      return { ...base(flag, rule.value, "RULE_MATCH"), ruleId: rule.id, ...rule.variationId ? { variationId: rule.variationId } : {} };
+    case "rollout": {
+      const hv = hashValueOf(ctx.attributes, rule.hashAttribute);
+      if (hv === void 0) return void 0;
+      if (hashBucket(rule.seed, hv) >= effectiveCoverage(rule, ctx.now)) return void 0;
+      return { ...base(flag, rule.value, "RULE_MATCH"), ruleId: rule.id, ...rule.variationId ? { variationId: rule.variationId } : {} };
+    }
+    case "split": {
+      const hv = hashValueOf(ctx.attributes, rule.hashAttribute);
+      if (hv === void 0 || !Array.isArray(rule.buckets)) return void 0;
+      const n = hashBucket(rule.seed, hv);
+      let cum = 0;
+      for (const b of rule.buckets) {
+        cum += Math.max(0, Number(b.weight) || 0);
+        if (n < cum) return { ...base(flag, b.value, "RULE_MATCH"), ruleId: rule.id, ...b.variationId ? { variationId: b.variationId } : {} };
+      }
+      return void 0;
+    }
+    case "experiment":
+      return runExperiment(ctx, flag, rule);
+    default:
+      return void 0;
+  }
+}
+function evalFlag(ctx, key) {
+  const flag = ctx.payload.flags?.[key];
+  if (!flag) return { key, value: null, reason: "FLAG_NOT_FOUND", inExperiment: false };
+  return enter(ctx, `flag:${key}`, () => {
+    if (!flag.enabled) return base(flag, flag.offValue, "DISABLED");
+    for (const p of flag.prerequisites ?? []) {
+      const ref = referencedValue(ctx, p.flag);
+      if (!ref || !compareFlag(p.operator, ref.value, p.value)) return base(flag, flag.offValue, "PREREQUISITE_FAILED");
+    }
+    for (const h of ctx.payload.holdouts ?? []) {
+      if (!Array.isArray(h.flags) || !h.flags.includes(key)) continue;
+      const hv = hashValueOf(ctx.attributes, h.hashAttribute);
+      if (hv !== void 0 && hashBucket(h.seed, hv) < clamp01(h.coverage)) return base(flag, flag.defaultValue, "HOLDOUT");
+    }
+    for (const rule of flag.rules ?? []) {
+      if (!rule || !isScheduleActive(rule.schedule, ctx.now)) continue;
+      if (!allMatch(ctx, rule.conditions)) continue;
+      const res = applyRule(ctx, flag, rule);
+      if (res) return res;
+    }
+    return base(flag, flag.defaultValue, "DEFAULT");
+  });
+}
+function evaluateFlag(payload, key, attributes = {}, options = {}) {
+  const ctx = { payload, attributes: attributes ?? {}, now: nowOf(options.now), sticky: options.stickyBuckets, stack: [] };
+  try {
+    return evalFlag(ctx, key);
+  } catch (err) {
+    return { key, value: null, reason: "ERROR", inExperiment: false, errorMessage: err instanceof Error ? err.message : String(err) };
+  }
+}
+
+// src/evaluator.ts
+function typeMatches(value, fallback) {
+  if (value === null || value === void 0) return false;
+  if (fallback === null || fallback === void 0) return true;
+  return kindOf(value) === kindOf(fallback);
+}
+function makeEvaluator(resolve2, all, attributes) {
+  const details = (key, fallback) => {
+    const r = resolve2(key);
+    const ok = typeMatches(r.value, fallback);
+    return { ...r, value: ok ? r.value : fallback, usedFallback: !ok };
+  };
+  const of = (type, key, fallback) => {
+    const v = resolve2(key).value;
+    return kindOf(v) === type ? v : fallback;
+  };
+  return {
+    isEnabled: (key, fallback = false) => of("boolean", key, fallback),
+    getValue: (key, fallback) => details(key, fallback).value,
+    getString: (key, fallback) => of("string", key, fallback),
+    getNumber: (key, fallback) => of("number", key, fallback),
+    getBoolean: (key, fallback) => of("boolean", key, fallback),
+    getJson: (key, fallback) => {
+      const v = resolve2(key).value;
+      return v !== null && typeof v === "object" ? v : fallback;
+    },
+    getDetails: details,
+    getAll: all,
+    getAttributes: attributes
+  };
+}
+function notFound(key) {
+  return { key, value: null, reason: "FLAG_NOT_FOUND", inExperiment: false };
+}
+
+// src/sse.ts
+function createSseParser(onEvent) {
+  let buffer = "";
+  const dispatch = (raw) => {
+    let event = "message";
+    const data = [];
+    for (const line of raw.split("\n")) {
+      if (!line || line.startsWith(":")) continue;
+      const i = line.indexOf(":");
+      const field = i < 0 ? line : line.slice(0, i);
+      const value = i < 0 ? "" : line.slice(i + 1).replace(/^ /, "");
+      if (field === "event") event = value;
+      else if (field === "data") data.push(value);
+    }
+    if (data.length) onEvent(event, data.join("\n"));
+  };
+  return {
+    feed(chunk) {
+      buffer += chunk.replace(/\r\n?/g, "\n");
+      let sep2;
+      while ((sep2 = buffer.indexOf("\n\n")) >= 0) {
+        dispatch(buffer.slice(0, sep2));
+        buffer = buffer.slice(sep2 + 2);
+      }
+    },
+    end() {
+      if (buffer.trim()) dispatch(buffer);
+      buffer = "";
+    }
+  };
+}
+
+// src/client.ts
+var FLAGS_SDK_NAME = "@guidelytech/flags";
+var FLAGS_SDK_VERSION = "0.8.0";
+var DEFAULT_FLAGS_API_URL = "https://guidelytech.com";
+var SECRET_PREFIX = "gly_sk_";
+var MAX_RESULT_CACHE = 20;
+var MAX_QUEUE = 1e3;
+var USAGE_FLUSH_MS = 6e4;
+var EXPOSURE_FLUSH_MS = 5e3;
+var MAX_BACKOFF_MS = 5 * 6e4;
+var isBrowser = () => typeof window !== "undefined" && typeof document !== "undefined";
+function defaultStorage() {
+  try {
+    if (!isBrowser() || typeof localStorage === "undefined") return null;
+    const probe = "__guidely_flags_probe__";
+    localStorage.setItem(probe, "1");
+    localStorage.removeItem(probe);
+    return localStorage;
+  } catch {
+    return null;
+  }
+}
+function backoff(failures, capMs) {
+  const base2 = Math.min(capMs, 1e3 * 2 ** Math.max(0, failures - 1));
+  return Math.round(base2 * (0.8 + Math.random() * 0.4));
+}
+var FlagsClient = class {
+  constructor(options) {
+    __publicField(this, "sdkKey");
+    __publicField(this, "apiUrl");
+    __publicField(this, "environment");
+    __publicField(this, "o");
+    __publicField(this, "cfg");
+    __publicField(this, "secret");
+    __publicField(this, "log");
+    __publicField(this, "storage");
+    __publicField(this, "storageKey");
+    __publicField(this, "getters");
+    __publicField(this, "payload", null);
+    /** The payload as received (possibly encrypted): what `getPayload()` hands to browsers. */
+    __publicField(this, "raw", null);
+    __publicField(this, "etag", null);
+    __publicField(this, "remote");
+    __publicField(this, "results", null);
+    __publicField(this, "resultsKey", null);
+    __publicField(this, "resultCache", /* @__PURE__ */ new Map());
+    __publicField(this, "context");
+    __publicField(this, "attributes");
+    __publicField(this, "overrides");
+    __publicField(this, "devOverrides");
+    __publicField(this, "urlOverrides");
+    __publicField(this, "offline");
+    __publicField(this, "destroyed", false);
+    __publicField(this, "ready_", false);
+    __publicField(this, "resolveReady");
+    __publicField(this, "readyPromise");
+    __publicField(this, "listeners", /* @__PURE__ */ new Set());
+    __publicField(this, "inflight", null);
+    __publicField(this, "lastFetchAt", 0);
+    __publicField(this, "failures", 0);
+    __publicField(this, "retryAt", 0);
+    __publicField(this, "pollTimer", null);
+    __publicField(this, "remoteTimer", null);
+    __publicField(this, "flushTimer", null);
+    __publicField(this, "flushDue", Infinity);
+    __publicField(this, "stream", null);
+    __publicField(this, "streamConnected", false);
+    __publicField(this, "streamFailures", 0);
+    __publicField(this, "reconnectTimer", null);
+    __publicField(this, "exposed", /* @__PURE__ */ new Set());
+    __publicField(this, "usage", /* @__PURE__ */ new Map());
+    __publicField(this, "exposures", []);
+    __publicField(this, "warned", /* @__PURE__ */ new Set());
+    __publicField(this, "cleanups", []);
+    __publicField(this, "lastError", "");
+    /** Calls `listener` whenever values may have changed (payload, attributes, overrides, readiness). */
+    __publicField(this, "subscribe", (listener) => {
+      this.listeners.add(listener);
+      return () => void this.listeners.delete(listener);
+    });
+    const o = options ?? {};
+    this.o = o;
+    const key = o.sdkKey ?? o.projectId ?? "";
+    if (!key) throw new Error("[Guidely flags] `sdkKey` (your environment public key pk_\u2026, or a gly_sk_\u2026 secret key on servers) is required.");
+    this.sdkKey = key;
+    this.secret = key.startsWith(SECRET_PREFIX);
+    this.environment = o.environment;
+    this.apiUrl = (o.apiUrl || DEFAULT_FLAGS_API_URL).replace(/\/+$/, "");
+    this.log = o.logger === null ? {} : o.logger ?? { warn: (...a) => console.warn("[Guidely flags]", ...a), error: (...a) => console.error("[Guidely flags]", ...a) };
+    if (this.secret && !o.environment) throw new Error("[Guidely flags] `environment` (development | staging | production) is required with a gly_sk_ key.");
+    if (this.secret && isBrowser()) this.log.warn?.("A gly_sk_ secret key is being used in a browser. Secret keys belong on servers; use the environment's public pk_ key here.");
+    const dev = o.devOverrides === false ? null : readDevOverrides();
+    this.cfg = {
+      mode: o.pollingMode ?? "auto",
+      pollMs: Math.max(1, o.pollIntervalSeconds ?? 60) * 1e3,
+      ttlMs: Math.max(0, o.cacheTtlSeconds ?? 60) * 1e3,
+      debounceMs: Math.max(0, o.remoteEvalDebounceMs ?? 50),
+      behaviour: dev?.behaviour ?? o.overrideBehaviour ?? "localOverRemote",
+      trackExposures: o.trackExposures ?? !o.trackingCallback,
+      reportUsage: o.reportUsage ?? true
+    };
+    this.remote = !!o.remoteEval;
+    this.offline = !!o.offline;
+    this.context = compact(o.contextAttributes ?? {});
+    this.attributes = compact(o.attributes ?? {});
+    this.overrides = { ...o.overrides ?? {} };
+    this.devOverrides = dev?.values ?? {};
+    this.urlOverrides = o.enableUrlOverrides && isBrowser() ? parseUrlOverrides(location.search) : {};
+    this.storage = o.storage === false || o.storage === null ? null : o.storage ?? defaultStorage();
+    this.storageKey = `guidely:flags:${key}${o.environment && this.secret ? `:${o.environment}` : ""}`;
+    this.readyPromise = new Promise((r) => this.resolveReady = r);
+    if (dev) {
+      dev.errors.forEach((e) => this.reportError(new Error(e)));
+      const n = Object.keys(dev.values).length;
+      if (dev.sources.length) this.log.warn?.(`Dev overrides from ${dev.sources.join(", ")}: ${n} flag${n === 1 ? "" : "s"}, behaviour ${this.cfg.behaviour}.`);
+    }
+    this.getters = makeEvaluator(
+      (k) => this.resolve(k, this.getAttributes(), true),
+      () => this.all(this.getAttributes()),
+      () => this.getAttributes()
+    );
+    const boot = o.payload;
+    if (isRemoteResults(boot)) this.setResults(boot, stableStringify(this.getAttributes()), false);
+    else if (isFlagsPayload(boot) && !isEncryptedPayload(boot)) this.setPayload(boot, boot, null, false);
+    if (o.remoteResults) {
+      const r = o.remoteResults;
+      this.setResults(isRemoteResults(r) && typeof r.version === "number" ? r : { version: 0, flags: o.remoteResults }, stableStringify(this.getAttributes()), false);
+    }
+    if (this.results) this.remote = true;
+    this.wireBrowser();
+    if (this.payload || this.results) this.settle();
+    void this.start();
+  }
+  // ---------------------------------------------------------------------------
+  // Getters (never throw)
+  // ---------------------------------------------------------------------------
+  /** Boolean flag value; `fallback` (default `false`) when missing or not a boolean. */
+  isEnabled(key, fallback = false) {
+    return this.getters.isEnabled(key, fallback);
+  }
+  /** Flag value; `fallback` when missing, null or of a different JSON type than `fallback`. */
+  getValue(key, fallback) {
+    return this.getters.getValue(key, fallback);
+  }
+  getString(key, fallback) {
+    return this.getters.getString(key, fallback);
+  }
+  getNumber(key, fallback) {
+    return this.getters.getNumber(key, fallback);
+  }
+  getBoolean(key, fallback) {
+    return this.getters.getBoolean(key, fallback);
+  }
+  getJson(key, fallback) {
+    return this.getters.getJson(key, fallback);
+  }
+  /** Value plus reason, rule, variation and experiment assignment. */
+  getDetails(key, fallback) {
+    return this.getters.getDetails(key, fallback);
+  }
+  /** Every flag's value for the current attributes (records no exposures or usage). */
+  getAll() {
+    return this.getters.getAll();
+  }
+  /**
+   * Getters bound to other attributes (merged over the client's), without changing the client:
+   * the per-request pattern on servers. With remote evaluation they serve results already cached
+   * for these attributes, else fallbacks.
+   */
+  forUser(attributes) {
+    const attrs = { ...this.getAttributes(), ...compact(attributes ?? {}) };
+    if (this.remote) this.warnOnce("forUser:remote", "forUser() with remote evaluation only serves results cached for those attributes.");
+    return makeEvaluator(
+      (k) => this.resolve(k, attrs, true),
+      () => this.all(attrs),
+      () => ({ ...attrs })
+    );
+  }
+  // ---------------------------------------------------------------------------
+  // Attributes and overrides
+  // ---------------------------------------------------------------------------
+  /** Replaces the app attributes. */
+  setAttributes(attributes) {
+    this.changeAttributes(() => this.attributes = compact(attributes ?? {}));
+  }
+  /** Merges into the app attributes. */
+  updateAttributes(partial) {
+    this.changeAttributes(() => this.attributes = compact({ ...this.attributes, ...partial }));
+  }
+  /** Replaces the integration-supplied attributes (see `contextAttributes`). */
+  setContextAttributes(attributes) {
+    this.changeAttributes(() => this.context = compact(attributes ?? {}));
+  }
+  /** Context attributes with app attributes merged over them. */
+  getAttributes() {
+    return { ...this.context, ...this.attributes };
+  }
+  /** Replaces the overrides (`null` clears them). Dev and URL overrides stay. */
+  setOverrides(overrides) {
+    this.overrides = { ...overrides ?? {} };
+    this.notify();
+  }
+  changeAttributes(apply) {
+    const before = stableStringify(this.getAttributes());
+    apply();
+    const after = stableStringify(this.getAttributes());
+    if (before === after) return;
+    if (this.remote) {
+      const cached = this.resultCache.get(after);
+      if (cached) {
+        this.results = cached;
+        this.resultsKey = after;
+      }
+      this.scheduleRemote();
+    }
+    this.notify();
+  }
+  // ---------------------------------------------------------------------------
+  // Lifecycle
+  // ---------------------------------------------------------------------------
+  /** Resolves once the first load settled (bootstrap, network success or failure). Never rejects. */
+  ready() {
+    return this.readyPromise;
+  }
+  isReady() {
+    return this.ready_;
+  }
+  /** `true` stops all network activity; cached data keeps serving. `false` resumes and refreshes. */
+  setOffline(offline) {
+    if (this.offline === offline) return;
+    this.offline = offline;
+    if (offline) return this.stopNetwork();
+    void this.refresh().then(() => this.schedule());
+  }
+  /** Fetches now (payload, or remote evaluation). Resolves when done; never rejects. */
+  async refresh() {
+    await this.fetchNow();
+  }
+  /**
+   * The current data for server-side rendering: pass it as `payload` to the browser client (or
+   * framework provider) to render the same values without a flash. Encrypted payloads stay
+   * encrypted; with remote evaluation it returns the results. `null` before anything loaded.
+   */
+  getPayload() {
+    if (this.remote) return this.results;
+    return this.raw;
+  }
+  /** Sends pending usage counts and exposures now. */
+  async flush() {
+    const batch = this.takeBatch();
+    if (!batch) return;
+    try {
+      const res = await this.request("POST", "/flags/events", { body: batch, keepalive: true });
+      if (!res.ok && (res.status >= 500 || res.status === 429)) this.requeue(batch);
+    } catch {
+      this.requeue(batch);
+    }
+  }
+  /** Stops timers and streams and sends pending usage. The client keeps serving cached values. */
+  destroy() {
+    if (this.destroyed) return;
+    this.flushOnExit();
+    this.destroyed = true;
+    this.stopNetwork();
+    if (this.flushTimer) clearTimeout(this.flushTimer);
+    this.cleanups.splice(0).forEach((fn) => fn());
+    this.listeners.clear();
+    this.settle();
+  }
+  // ---------------------------------------------------------------------------
+  // Evaluation
+  // ---------------------------------------------------------------------------
+  overrideFor(key) {
+    if (Object.prototype.hasOwnProperty.call(this.urlOverrides, key)) return this.urlOverrides[key];
+    if (Object.prototype.hasOwnProperty.call(this.devOverrides, key)) return this.devOverrides[key];
+    if (Object.prototype.hasOwnProperty.call(this.overrides, key)) return this.overrides[key];
+    return void 0;
+  }
+  resolve(key, attrs, track) {
+    let res;
+    try {
+      if (this.cfg.mode === "lazy") this.lazyRefresh();
+      const ov = this.overrideFor(key);
+      const forced = Object.prototype.hasOwnProperty.call(this.urlOverrides, key);
+      const override = ov === void 0 ? null : { key, value: ov, reason: "OVERRIDE", inExperiment: false };
+      if (override && (forced || this.cfg.behaviour !== "remoteOverLocal")) res = override;
+      else {
+        res = this.evaluateRemoteOrLocal(key, attrs);
+        if (override && res.reason === "FLAG_NOT_FOUND") res = override;
+      }
+    } catch (err) {
+      res = { key, value: null, reason: "ERROR", inExperiment: false, errorMessage: err instanceof Error ? err.message : String(err) };
+    }
+    if (track) this.record(res, attrs);
+    return res;
+  }
+  evaluateRemoteOrLocal(key, attrs) {
+    if (this.remote) {
+      const k = stableStringify(attrs);
+      const results = k === this.resultsKey || k === stableStringify(this.getAttributes()) ? this.results : this.resultCache.get(k);
+      return results?.flags[key] ?? notFound(key);
+    }
+    if (!this.payload) return notFound(key);
+    return evaluateFlag(this.payload, key, attrs, { now: this.now(), stickyBuckets: this.o.stickyBucketService });
+  }
+  all(attrs) {
+    const keys = /* @__PURE__ */ new Set([...Object.keys(this.overrides), ...Object.keys(this.devOverrides), ...Object.keys(this.urlOverrides)]);
+    if (this.remote) for (const k of Object.keys(this.results?.flags ?? {})) keys.add(k);
+    else for (const k of Object.keys(this.payload?.flags ?? {})) keys.add(k);
+    const out = {};
+    for (const k of keys) {
+      const v = this.resolve(k, attrs, false).value;
+      if (v !== null) out[k] = v;
+    }
+    return out;
+  }
+  now() {
+    const n = this.o.now?.();
+    return n === void 0 ? Date.now() : typeof n === "number" ? n : n.getTime();
+  }
+  record(res, attrs) {
+    try {
+      this.o.onFlagEvaluated?.(res);
+    } catch (err) {
+      this.reportError(err);
+    }
+    if (res.reason === "FLAG_NOT_FOUND") {
+      if (this.ready_ && (this.payload || this.results) && isDev()) this.warnOnce(`missing:${res.key}`, `Flag "${res.key}" does not exist in this environment; serving the fallback.`);
+      return;
+    }
+    if (res.reason === "OVERRIDE" || res.reason === "ERROR") return;
+    if (this.cfg.reportUsage) {
+      const value = (JSON.stringify(res.value) ?? "null").slice(0, 200);
+      const k = `${res.key}\0${res.variationId ?? ""}\0${res.variationId ? "" : value}`;
+      const u = this.usage.get(k);
+      if (u) u.count++;
+      else if (this.usage.size < MAX_QUEUE) this.usage.set(k, { flag: res.key, ...res.variationId ? { variationId: res.variationId } : {}, value, count: 1 });
+      this.scheduleFlush(USAGE_FLUSH_MS);
+    }
+    const exp = res.inExperiment ? res.experiment : void 0;
+    if (!exp) return;
+    const dedupe = `${exp.key}\0${exp.hashValue}\0${exp.variationId}`;
+    if (this.exposed.has(dedupe)) return;
+    if (this.exposed.size >= 5e4) this.exposed.clear();
+    this.exposed.add(dedupe);
+    try {
+      this.o.trackingCallback?.(exp, res);
+    } catch (err) {
+      this.reportError(err);
+    }
+    if (!this.cfg.trackExposures) return;
+    const userId = textOf(attrs.id);
+    const anonymousId = textOf(attrs.anonymousId);
+    if (this.exposures.length < MAX_QUEUE) {
+      this.exposures.push({ experiment: exp.key, flag: res.key, variationId: exp.variationId, hashAttribute: exp.hashAttribute, hashValue: exp.hashValue, ...userId ? { userId } : {}, ...anonymousId ? { anonymousId } : {}, timestamp: new Date(this.now()).toISOString() });
+    }
+    this.scheduleFlush(EXPOSURE_FLUSH_MS);
+  }
+  warnOnce(id, message) {
+    if (this.warned.has(id)) return;
+    this.warned.add(id);
+    this.log.warn?.(message);
+  }
+  // ---------------------------------------------------------------------------
+  // Data
+  // ---------------------------------------------------------------------------
+  setPayload(payload, raw, etag, emit) {
+    const same = this.payload && this.payload.version === payload.version && this.payload.generatedAt === payload.generatedAt && this.payload.environment === payload.environment;
+    this.payload = payload;
+    this.raw = raw;
+    this.etag = etag;
+    if (!emit || same) return;
+    try {
+      this.o.onChange?.(payload);
+    } catch (err) {
+      this.reportError(err);
+    }
+    this.notify();
+  }
+  setResults(results, key, emit) {
+    this.resultCache.delete(key);
+    this.resultCache.set(key, results);
+    while (this.resultCache.size > MAX_RESULT_CACHE) this.resultCache.delete(this.resultCache.keys().next().value);
+    if (key !== stableStringify(this.getAttributes())) return;
+    const same = this.results && stableStringify(this.results) === stableStringify(results);
+    this.results = results;
+    this.resultsKey = key;
+    if (!emit || same) return;
+    try {
+      this.o.onChange?.(results);
+    } catch (err) {
+      this.reportError(err);
+    }
+    this.notify();
+  }
+  /** Decrypts when needed and applies. Returns false (keeping the previous payload) when unusable. */
+  async applyRaw(raw, etag) {
+    if (isEncryptedPayload(raw)) {
+      if (!this.o.decryptionKey) {
+        this.reportError(new Error("The payload is encrypted but no `decryptionKey` was given; keeping the previous flags."));
+        return false;
+      }
+      try {
+        const plain = JSON.parse(await decryptPayloadString(raw.encryptedPayload, this.o.decryptionKey));
+        const envelope = { ...raw };
+        delete envelope.encryptedPayload;
+        const merged = { ...envelope, ...plain };
+        if (!isFlagsPayload(merged)) throw new Error("decrypted payload has no flags");
+        this.setPayload(merged, raw, etag, true);
+        return true;
+      } catch (err) {
+        this.reportError(new Error(`Could not decrypt the flags payload (${err instanceof Error ? err.message : String(err)}); keeping the previous flags.`));
+        return false;
+      }
+    }
+    if (!isFlagsPayload(raw)) {
+      this.reportError(new Error("Unexpected flags payload; keeping the previous flags."));
+      return false;
+    }
+    this.setPayload(raw, raw, etag, true);
+    return true;
+  }
+  async loadStored() {
+    if (!this.storage) return;
+    try {
+      const text = await this.storage.getItem(this.storageKey);
+      if (!text || this.payload) return;
+      const saved = JSON.parse(text);
+      if (saved?.payload && !this.payload) await this.applyRaw(saved.payload, saved.etag ?? null);
+    } catch (err) {
+      this.log.debug?.("could not read cached flags", err);
+    }
+  }
+  persist() {
+    if (!this.storage || !this.raw) return;
+    try {
+      void Promise.resolve(this.storage.setItem(this.storageKey, JSON.stringify({ payload: this.raw, etag: this.etag, savedAt: (/* @__PURE__ */ new Date()).toISOString() }))).catch(() => {
+      });
+    } catch {
+    }
+  }
+  // ---------------------------------------------------------------------------
+  // Network
+  // ---------------------------------------------------------------------------
+  url(path) {
+    const q = this.secret ? `environment=${encodeURIComponent(this.environment ?? "")}` : `key=${encodeURIComponent(this.sdkKey)}`;
+    return `${this.apiUrl}/api/v1/sdk${path}?${q}`;
+  }
+  headers(extra = {}) {
+    return { ...extra, ...this.secret ? { Authorization: `Bearer ${this.sdkKey}` } : { "X-Guidely-Key": this.sdkKey } };
+  }
+  get fetcher() {
+    if (this.o.fetch) return this.o.fetch;
+    return typeof fetch === "function" ? fetch.bind(globalThis) : null;
+  }
+  async request(method, path, opts = {}) {
+    const f = this.fetcher;
+    if (!f) throw new Error("fetch is not available; pass `fetch`");
+    const headers = this.headers({ Accept: "application/json" });
+    if (opts.body !== void 0) headers["Content-Type"] = "application/json";
+    if (opts.etag) headers["If-None-Match"] = opts.etag;
+    const ac = typeof AbortController !== "undefined" ? new AbortController() : null;
+    const t = ac ? timer(() => ac.abort(), opts.timeoutMs ?? 1e4) : null;
+    try {
+      const browserOnly = isBrowser() ? { credentials: "omit", keepalive: opts.keepalive } : {};
+      const res = await f(this.url(path), { method, headers, body: opts.body === void 0 ? void 0 : JSON.stringify(opts.body), signal: ac?.signal, ...browserOnly });
+      let data = null;
+      if (res.status !== 304 && res.status !== 204) {
+        try {
+          data = await res.json();
+        } catch {
+          data = null;
+        }
+      }
+      return { status: res.status, ok: res.ok, data, etag: res.headers?.get?.("etag") ?? null };
+    } finally {
+      if (t) clearTimeout(t);
+    }
+  }
+  fetchNow() {
+    if (this.destroyed || this.offline || this.cfg.behaviour === "localOnly") return Promise.resolve(false);
+    if (this.inflight) return this.inflight;
+    this.inflight = (this.remote ? this.fetchRemote() : this.fetchPayload()).catch((err) => {
+      this.reportError(err);
+      return false;
+    }).then((ok) => {
+      this.inflight = null;
+      this.lastFetchAt = Date.now();
+      this.failures = ok ? 0 : this.failures + 1;
+      this.retryAt = ok ? 0 : Date.now() + backoff(this.failures, Math.max(this.cfg.pollMs, MAX_BACKOFF_MS));
+      if (ok) this.lastError = "";
+      return ok;
+    });
+    return this.inflight;
+  }
+  async fetchPayload() {
+    let res;
+    try {
+      res = await this.request("GET", "/flags", { etag: this.payload ? this.etag : null });
+    } catch (err) {
+      this.reportError(new Error(`Flags request failed: ${err instanceof Error ? err.message : String(err)}`));
+      return false;
+    }
+    if (res.status === 304) return true;
+    const code = res.data?.error?.code;
+    if (res.status === 403 && code === "remote_evaluation_required" && !this.secret) {
+      this.log.warn?.("This environment requires remote evaluation; switching to `remoteEval: true`.");
+      this.remote = true;
+      return this.fetchRemote();
+    }
+    if (!res.ok || res.data == null) {
+      this.reportError(new Error(`Flags request failed (${res.status}${code ? ` ${code}` : ""})${this.payload ? "; serving the last good flags" : ""}`));
+      return false;
+    }
+    const applied = await this.applyRaw(res.data, res.etag);
+    if (applied) this.persist();
+    return applied;
+  }
+  async fetchRemote() {
+    const attrs = this.getAttributes();
+    const key = stableStringify(attrs);
+    let res;
+    try {
+      res = await this.request("POST", "/flags/evaluate", { body: { attributes: attrs } });
+    } catch (err) {
+      this.reportError(new Error(`Remote evaluation failed: ${err instanceof Error ? err.message : String(err)}`));
+      return false;
+    }
+    if (!res.ok || !res.data || !isRemoteResults(res.data)) {
+      this.reportError(new Error(`Remote evaluation failed (${res.status})`));
+      return false;
+    }
+    this.setResults(res.data, key, true);
+    return true;
+  }
+  scheduleRemote() {
+    if (this.destroyed || this.offline || this.cfg.behaviour === "localOnly") return;
+    if (this.remoteTimer) clearTimeout(this.remoteTimer);
+    this.remoteTimer = timer(() => {
+      this.remoteTimer = null;
+      void this.fetchRemote().then((ok) => {
+        if (!ok) this.failures++;
+      });
+    }, this.cfg.debounceMs);
+  }
+  lazyRefresh() {
+    if (this.inflight || this.offline || this.destroyed || this.cfg.behaviour === "localOnly") return;
+    const now = Date.now();
+    if (now - this.lastFetchAt < this.cfg.ttlMs || now < this.retryAt) return;
+    this.lastFetchAt = now;
+    void this.fetchNow();
+  }
+  async start() {
+    const boot = this.o.payload;
+    if (isEncryptedPayload(boot)) await this.applyRaw(boot, null);
+    if (!this.payload && !this.results && !this.remote && this.cfg.behaviour !== "localOnly") await this.loadStored();
+    if (this.destroyed) return;
+    const bootstrapped = !!(boot || this.o.remoteResults) && !!(this.payload || this.results);
+    if (this.cfg.behaviour === "localOnly" || this.offline || this.cfg.mode === "manual") return this.settle();
+    if (bootstrapped) {
+      this.settle();
+      await this.fetchNow();
+      return this.schedule();
+    }
+    await this.fetchNow();
+    this.settle();
+    this.schedule();
+  }
+  settle() {
+    if (this.ready_) return;
+    this.ready_ = true;
+    this.resolveReady();
+    try {
+      this.o.onReady?.();
+    } catch (err) {
+      this.reportError(err);
+    }
+    this.notify();
+  }
+  /** Arms the poll timer / stream for the current mode. */
+  schedule() {
+    if (this.destroyed || this.offline || this.cfg.behaviour === "localOnly") return;
+    if (this.cfg.mode === "auto") this.schedulePoll();
+    else if (this.cfg.mode === "stream") {
+      if (!this.stream) this.openStream();
+      if (!this.streamConnected) this.schedulePoll();
+    }
+  }
+  schedulePoll() {
+    if (this.pollTimer) clearTimeout(this.pollTimer);
+    const delay = this.failures ? Math.max(0, this.retryAt - Date.now()) : this.cfg.pollMs;
+    this.pollTimer = timer(() => {
+      this.pollTimer = null;
+      if (this.cfg.mode === "stream" && this.streamConnected) return;
+      if (isBrowser() && document.visibilityState === "hidden") return this.schedulePoll();
+      void this.fetchNow().then(() => this.schedule());
+    }, delay);
+  }
+  stopNetwork() {
+    for (const t of [this.pollTimer, this.remoteTimer, this.reconnectTimer]) if (t) clearTimeout(t);
+    this.pollTimer = this.remoteTimer = this.reconnectTimer = null;
+    this.stream?.close();
+    this.stream = null;
+    this.streamConnected = false;
+  }
+  // ---------------------------------------------------------------------------
+  // Streaming
+  // ---------------------------------------------------------------------------
+  onStreamEvent(event, data) {
+    if (event !== "flags") return;
+    let version;
+    try {
+      version = JSON.parse(data).version;
+    } catch {
+      return;
+    }
+    const current = this.remote ? this.results?.version ?? -1 : this.payload?.version ?? -1;
+    if (typeof version === "number" && version > current) void this.fetchNow();
+  }
+  openStream() {
+    if (this.destroyed || this.offline || this.stream) return;
+    const url = this.url("/flags/stream");
+    const ES = globalThis.EventSource;
+    const opened = () => {
+      this.streamConnected = true;
+      this.streamFailures = 0;
+      if (this.pollTimer) clearTimeout(this.pollTimer);
+      this.pollTimer = null;
+    };
+    if (ES && !this.secret) {
+      const es = new ES(url);
+      es.addEventListener("flags", (e) => this.onStreamEvent("flags", e.data));
+      es.onopen = opened;
+      es.onerror = () => {
+        es.close();
+        if (this.stream === handle2) this.streamDown();
+      };
+      const handle2 = { close: () => es.close() };
+      this.stream = handle2;
+      return;
+    }
+    const f = this.fetcher;
+    if (!f || typeof TextDecoder === "undefined") return this.streamDown(true);
+    const ac = typeof AbortController !== "undefined" ? new AbortController() : null;
+    const handle = { close: () => ac?.abort() };
+    this.stream = handle;
+    void (async () => {
+      try {
+        const res = await f(url, { headers: this.headers({ Accept: "text/event-stream" }), signal: ac?.signal, ...isBrowser() ? { credentials: "omit" } : {} });
+        const reader = res.ok ? res.body?.getReader?.() : void 0;
+        if (!reader) {
+          if (this.stream === handle) this.streamDown(res.ok);
+          return;
+        }
+        opened();
+        const parser = createSseParser((event, data) => this.onStreamEvent(event, data));
+        const decoder = new TextDecoder();
+        for (; ; ) {
+          const { done, value } = await reader.read();
+          if (value) parser.feed(decoder.decode(value, { stream: true }));
+          if (done) break;
+        }
+        parser.end();
+      } catch {
+      }
+      if (this.stream === handle) this.streamDown();
+    })();
+  }
+  /** The stream dropped: poll meanwhile and reconnect with backoff (`permanent`: never retry). */
+  streamDown(permanent = false) {
+    this.stream = null;
+    this.streamConnected = false;
+    if (this.destroyed || this.offline) return;
+    this.schedulePoll();
+    if (permanent) return;
+    this.streamFailures++;
+    if (this.reconnectTimer) clearTimeout(this.reconnectTimer);
+    this.reconnectTimer = timer(() => {
+      this.reconnectTimer = null;
+      this.openStream();
+      void this.fetchNow();
+    }, backoff(this.streamFailures, MAX_BACKOFF_MS));
+  }
+  // ---------------------------------------------------------------------------
+  // Usage + exposures
+  // ---------------------------------------------------------------------------
+  scheduleFlush(ms) {
+    if (this.destroyed) return;
+    const due = Date.now() + ms;
+    if (this.flushTimer && due >= this.flushDue) return;
+    if (this.flushTimer) clearTimeout(this.flushTimer);
+    this.flushDue = due;
+    this.flushTimer = timer(() => {
+      this.flushTimer = null;
+      this.flushDue = Infinity;
+      if (!this.offline) void this.flush();
+      else if (this.usage.size || this.exposures.length) this.scheduleFlush(USAGE_FLUSH_MS);
+    }, ms);
+  }
+  takeBatch() {
+    if (!this.usage.size && !this.exposures.length) return null;
+    if (this.cfg.behaviour === "localOnly") {
+      this.usage.clear();
+      this.exposures = [];
+      return null;
+    }
+    const batch = { sdk: this.o.sdk ?? { name: FLAGS_SDK_NAME, version: FLAGS_SDK_VERSION } };
+    if (this.usage.size) batch.usage = Array.from(this.usage.values());
+    if (this.exposures.length) batch.exposures = this.exposures;
+    this.usage.clear();
+    this.exposures = [];
+    return batch;
+  }
+  requeue(batch) {
+    for (const u of batch.usage ?? []) {
+      const k = `${u.flag}\0${u.variationId ?? ""}\0${u.variationId ? "" : u.value ?? ""}`;
+      const cur = this.usage.get(k);
+      if (cur) cur.count += u.count;
+      else if (this.usage.size < MAX_QUEUE) this.usage.set(k, { flag: u.flag, variationId: u.variationId, value: u.value ?? "", count: u.count });
+    }
+    this.exposures = [...batch.exposures ?? [], ...this.exposures].slice(0, MAX_QUEUE);
+    this.scheduleFlush(USAGE_FLUSH_MS);
+  }
+  /** Page hide / destroy: `sendBeacon` for public keys, else a `keepalive` fetch. */
+  flushOnExit() {
+    if (this.offline) return;
+    const batch = this.takeBatch();
+    if (!batch) return;
+    try {
+      if (!this.secret && typeof navigator !== "undefined" && typeof navigator.sendBeacon === "function" && typeof Blob !== "undefined") {
+        if (navigator.sendBeacon(this.url("/flags/events"), new Blob([JSON.stringify(batch)], { type: "text/plain;charset=UTF-8" }))) return;
+      }
+    } catch {
+    }
+    void this.request("POST", "/flags/events", { body: batch, keepalive: true }).catch(() => {
+    });
+  }
+  wireBrowser() {
+    if (!isBrowser()) return;
+    const onHide = () => this.flushOnExit();
+    const onVisibility = () => {
+      if (document.visibilityState === "hidden") return this.flushOnExit();
+      if ((this.cfg.mode === "auto" || this.cfg.mode === "stream" && !this.streamConnected) && Date.now() - this.lastFetchAt > this.cfg.pollMs) void this.fetchNow().then(() => this.schedule());
+    };
+    window.addEventListener("pagehide", onHide);
+    document.addEventListener("visibilitychange", onVisibility);
+    this.cleanups.push(() => {
+      window.removeEventListener("pagehide", onHide);
+      document.removeEventListener("visibilitychange", onVisibility);
+    });
+  }
+  // ---------------------------------------------------------------------------
+  notify() {
+    for (const l of Array.from(this.listeners)) {
+      try {
+        l();
+      } catch (err) {
+        this.reportError(err);
+      }
+    }
+  }
+  reportError(err) {
+    const error = err instanceof Error ? err : new Error(String(err));
+    if (error.message !== this.lastError) this.log.error?.(error.message);
+    this.lastError = error.message;
+    try {
+      this.o.onError?.(error);
+    } catch {
+    }
+  }
+};
+function createFlagsClient(options) {
+  return new FlagsClient(options);
+}
+
+// src/code-refs.ts
+var import_node_child_process = require("child_process");
+var import_node_fs = require("fs");
+var import_node_path = require("path");
+var SKIP_DIRS = /* @__PURE__ */ new Set(["node_modules", ".git", "dist", "build", "vendor", ".next", ".svelte-kit", ".turbo", "coverage", "target", "out"]);
+var SKIP_FILES = /(^|\/)(package-lock\.json|pnpm-lock\.yaml|yarn\.lock|bun\.lockb?|composer\.lock|Cargo\.lock|Gemfile\.lock|poetry\.lock)$|\.(min\.js|map|png|jpe?g|gif|webp|ico|svg|pdf|zip|gz|woff2?|ttf|eot|mp4|mov|mp3|jar|class|so|dylib|dll|exe|bin)$/i;
+var MAX_FILE_BYTES = 1024 * 1024;
+var MAX_REFS = 1e4;
+function listFiles(dir) {
+  try {
+    const out = (0, import_node_child_process.execFileSync)("git", ["ls-files", "-z", "--cached", "--others", "--exclude-standard"], { cwd: dir, encoding: "utf8", stdio: ["ignore", "pipe", "ignore"], maxBuffer: 256 * 1024 * 1024 });
+    const files2 = out.split("\0").filter(Boolean);
+    if (files2.length) return files2.filter((f) => !f.split("/").some((p) => SKIP_DIRS.has(p)));
+  } catch {
+  }
+  const files = [];
+  const walk = (abs) => {
+    let entries;
+    try {
+      entries = (0, import_node_fs.readdirSync)(abs, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const e of entries) {
+      if (e.isDirectory()) {
+        if (!SKIP_DIRS.has(e.name)) walk((0, import_node_path.join)(abs, e.name));
+      } else if (e.isFile()) files.push((0, import_node_path.relative)(dir, (0, import_node_path.join)(abs, e.name)).split(import_node_path.sep).join("/"));
+    }
+  };
+  walk(dir);
+  return files.sort();
+}
+var escapeRe = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+function scanFiles(dir, files, flagKeys) {
+  const keys = Array.from(new Set(flagKeys.filter(Boolean))).sort((a, b) => b.length - a.length);
+  if (!keys.length) return [];
+  const re = new RegExp(`(['"\`])(${keys.map(escapeRe).join("|")})\\1`, "g");
+  const refs = [];
+  for (const path of files) {
+    if (SKIP_FILES.test(path)) continue;
+    const abs = (0, import_node_path.join)(dir, path);
+    let text;
+    try {
+      const st = (0, import_node_fs.statSync)(abs);
+      if (!st.isFile() || st.size > MAX_FILE_BYTES) continue;
+      const buf = (0, import_node_fs.readFileSync)(abs);
+      if (buf.subarray(0, 8e3).includes(0)) continue;
+      text = buf.toString("utf8");
+    } catch {
+      continue;
+    }
+    if (!keys.some((k) => text.includes(k))) continue;
+    const lines = text.split(/\r?\n/);
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+      re.lastIndex = 0;
+      const seen = /* @__PURE__ */ new Set();
+      for (let m = re.exec(line); m; m = re.exec(line)) {
+        const flag = m[2];
+        if (seen.has(flag)) continue;
+        seen.add(flag);
+        refs.push({ flag, path, line: i + 1, snippet: line.trim().slice(0, 200) });
+        if (refs.length >= MAX_REFS) return refs;
+      }
+    }
+  }
+  return refs;
+}
+function gitValue(dir, args) {
+  try {
+    return (0, import_node_child_process.execFileSync)("git", args, { cwd: dir, encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }).trim() || void 0;
+  } catch {
+    return void 0;
+  }
+}
+
+// src/cli-main.ts
+var HELP = `guidely-flags \u2014 Guidely feature flag tools
+
+Usage:
+  guidely-flags code-refs --key gly_sk_\u2026 --environment production --repo <name> [options]
+  guidely-flags evaluate  --key <pk_\u2026|gly_sk_\u2026> [--environment <env>] [--flag <key>] [--attributes '{"id":"u1"}']
+
+code-refs: finds flag keys used as quoted string literals in your code and uploads the
+references, so the dashboard shows where each flag is used (run it in CI on your main branch).
+  --api-url <url>         Guidely URL (default ${DEFAULT_FLAGS_API_URL}; env GUIDELY_API_URL)
+  --key <gly_sk_\u2026>        Secret API key with flags:read and flags:code-refs (env GUIDELY_API_KEY)
+  --environment <env>     development | staging | production (env GUIDELY_ENVIRONMENT)
+  --repo <name>           Repository name, e.g. acme/web (env GITHUB_REPOSITORY)
+  --branch <branch>       Default: the current git branch
+  --commit <sha>          Default: the current git commit
+  --dir <path>            Directory to scan (default .)
+  --decryption-key <key>  For environments with encrypted payloads
+  --dry-run               Print the references instead of uploading them
+
+evaluate: prints how a flag (or every flag) evaluates for some attributes.
+  --flag <key>            Flag key (default: all flags)
+  --attributes <json>     Attributes object (default {})
+
+Exit codes: 0 success, 1 failure, 2 usage error.
+`;
+var UsageError = class extends Error {
+};
+function parseArgs(argv) {
+  const flags = {};
+  let command;
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (a.startsWith("--")) {
+      const eq = a.indexOf("=");
+      if (eq > 0) flags[a.slice(2, eq)] = a.slice(eq + 1);
+      else if (argv[i + 1] !== void 0 && !argv[i + 1].startsWith("--")) flags[a.slice(2)] = argv[++i];
+      else flags[a.slice(2)] = true;
+    } else if (a === "-h") flags.help = true;
+    else if (!command) command = a;
+    else throw new UsageError(`Unexpected argument: ${a}`);
+  }
+  return { command, flags };
+}
+async function main(argv, io = {}) {
+  const env2 = io.env ?? process.env;
+  const out = io.out ?? ((t) => process.stdout.write(t));
+  const err = io.err ?? ((t) => process.stderr.write(t));
+  const doFetch = io.fetch ?? fetch;
+  try {
+    const { command, flags } = parseArgs(argv);
+    if (!command || flags.help || command === "help") {
+      out(HELP);
+      return command || flags.help ? 0 : 2;
+    }
+    const str = (name, envName) => {
+      const v = flags[name];
+      if (v === true) throw new UsageError(`--${name} needs a value`);
+      return v ?? (envName ? env2[envName] : void 0) ?? void 0;
+    };
+    const apiUrl = (str("api-url", "GUIDELY_API_URL") || DEFAULT_FLAGS_API_URL).replace(/\/+$/, "");
+    const key = str("key", "GUIDELY_API_KEY");
+    const environment = str("environment", "GUIDELY_ENVIRONMENT");
+    if (!key) throw new UsageError("--key is required");
+    if (command === "code-refs") {
+      if (!key.startsWith("gly_sk_")) throw new UsageError("code-refs needs a secret gly_sk_ API key");
+      if (!environment) throw new UsageError("--environment is required");
+      const dir = (0, import_node_path2.resolve)(io.cwd ?? process.cwd(), str("dir") ?? ".");
+      const repo = str("repo", "GITHUB_REPOSITORY");
+      if (!repo) throw new UsageError("--repo is required");
+      const branch = str("branch") ?? env2.GITHUB_HEAD_REF ?? env2.GITHUB_REF_NAME ?? gitValue(dir, ["rev-parse", "--abbrev-ref", "HEAD"]);
+      if (!branch) throw new UsageError("--branch is required (not a git checkout)");
+      const commit = str("commit") ?? env2.GITHUB_SHA ?? gitValue(dir, ["rev-parse", "HEAD"]);
+      const auth = { Authorization: `Bearer ${key}`, Accept: "application/json" };
+      const res = await doFetch(`${apiUrl}/api/v1/sdk/flags?environment=${encodeURIComponent(environment)}`, { headers: auth });
+      if (!res.ok) throw new Error(`Downloading flags failed (${res.status}): ${(await res.text()).slice(0, 300)}`);
+      let payload = await res.json();
+      if (isEncryptedPayload(payload)) {
+        const dk = str("decryption-key", "GUIDELY_DECRYPTION_KEY");
+        if (!dk) throw new Error("The payload is encrypted: pass --decryption-key");
+        payload = { ...payload, ...JSON.parse(await decryptPayloadString(payload.encryptedPayload, dk)) };
+      }
+      if (!isFlagsPayload(payload)) throw new Error("Unexpected flags payload");
+      const keys = Object.keys(payload.flags);
+      const files = listFiles(dir);
+      const refs = scanFiles(dir, files, keys);
+      if (refs.length >= MAX_REFS) err(`Stopped after ${MAX_REFS} references.
+`);
+      if (flags["dry-run"]) {
+        for (const r of refs) out(`${r.flag}	${r.path}:${r.line}	${r.snippet}
+`);
+        out(`${refs.length} reference(s) to ${new Set(refs.map((r) => r.flag)).size} of ${keys.length} flag(s) in ${files.length} file(s) (dry run, nothing uploaded)
+`);
+        return 0;
+      }
+      const up = await doFetch(`${apiUrl}/api/v1/flags/code-refs`, { method: "POST", headers: { ...auth, "Content-Type": "application/json" }, body: JSON.stringify({ repo, branch, ...commit ? { commit } : {}, refs }) });
+      if (!up.ok) throw new Error(`Uploading code references failed (${up.status}): ${(await up.text()).slice(0, 300)}`);
+      out(`Uploaded ${refs.length} reference(s) to ${new Set(refs.map((r) => r.flag)).size} flag(s) for ${repo}@${branch}
+`);
+      return 0;
+    }
+    if (command === "evaluate") {
+      let attributes = {};
+      const raw = str("attributes");
+      if (raw) {
+        try {
+          attributes = JSON.parse(raw);
+        } catch {
+          throw new UsageError("--attributes must be a JSON object");
+        }
+        if (!attributes || typeof attributes !== "object" || Array.isArray(attributes)) throw new UsageError("--attributes must be a JSON object");
+      }
+      let failure = null;
+      const client = createFlagsClient({ sdkKey: key, apiUrl, environment, pollingMode: "manual", reportUsage: false, trackExposures: false, storage: false, logger: null, fetch: doFetch, decryptionKey: str("decryption-key", "GUIDELY_DECRYPTION_KEY"), onError: (e) => failure = e });
+      await client.refresh();
+      client.destroy();
+      if (!client.getPayload()) throw failure ?? new Error("Could not load flags");
+      const user = client.forUser(attributes);
+      const flag = str("flag");
+      const result = flag ? user.getDetails(flag, null) : user.getAll();
+      out(`${JSON.stringify(result, null, 2)}
+`);
+      return 0;
+    }
+    throw new UsageError(`Unknown command: ${command}`);
+  } catch (e) {
+    if (e instanceof UsageError) {
+      err(`${e.message}
+
+${HELP}`);
+      return 2;
+    }
+    err(`guidely-flags: ${e instanceof Error ? e.message : String(e)}
+`);
+    return 1;
+  }
+}
+
+// src/cli.ts
+main(process.argv.slice(2)).then((code) => process.exit(code));
+//# sourceMappingURL=cli.cjs.map