@guidelytech/flags 0.9.0 → 0.11.0

package/dist/chunk-ZTY7K7P2.js

@@ -1,988 +0,0 @@
-import {
-  __publicField,
-  decodeUtf8,
-  evaluateFlag,
-  textOf
-} from "./chunk-OY4QS3WL.js";
-
-// 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") {
-  const out = {};
-  let raw = null;
-  try {
-    raw = new URLSearchParams(search.startsWith("?") ? search.slice(1) : search).get(param);
-  } catch {
-    return out;
-  }
-  if (!raw) return 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 === "," && depth === 0) {
-      items.push(raw.slice(start, i));
-      start = i + 1;
-    }
-  }
-  items.push(raw.slice(start));
-  for (const item of items) {
-    const sep = item.indexOf(":");
-    if (sep <= 0) continue;
-    const key = item.slice(0, sep).trim();
-    const text = item.slice(sep + 1).trim();
-    if (!key) continue;
-    try {
-      out[key] = JSON.parse(text);
-    } catch {
-      out[key] = text;
-    }
-  }
-  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/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(resolve, all, attributes) {
-  const details = (key, fallback) => {
-    const r = resolve(key);
-    const ok = typeMatches(r.value, fallback);
-    return { ...r, value: ok ? r.value : fallback, usedFallback: !ok };
-  };
-  const of = (type, key, fallback) => {
-    const v = resolve(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 = resolve(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 };
-}
-function createStaticFlags(input = {}) {
-  const attrs = { ...input.attributes ?? {} };
-  const p = input.payload;
-  const payload = isFlagsPayload(p) && !isEncryptedPayload(p) ? p : null;
-  const results = !payload && isRemoteResults(p) ? p.flags : null;
-  const resolve = (key) => {
-    try {
-      if (payload) return evaluateFlag(payload, key, attrs, { now: input.now });
-      return results?.[key] ?? notFound(key);
-    } catch {
-      return notFound(key);
-    }
-  };
-  const all = () => {
-    const out = {};
-    for (const key of Object.keys(payload?.flags ?? results ?? {})) out[key] = resolve(key).value;
-    return out;
-  };
-  return { ...makeEvaluator(resolve, all, () => ({ ...attrs })), isReady: () => !!(payload || results), subscribe: () => () => {
-  } };
-}
-
-// 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/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 sep;
-      while ((sep = buffer.indexOf("\n\n")) >= 0) {
-        dispatch(buffer.slice(0, sep));
-        buffer = buffer.slice(sep + 2);
-      }
-    },
-    end() {
-      if (buffer.trim()) dispatch(buffer);
-      buffer = "";
-    }
-  };
-}
-
-// src/client.ts
-var FLAGS_SDK_NAME = "@guidelytech/flags";
-var FLAGS_SDK_VERSION = "0.7.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 base = Math.min(capMs, 1e3 * 2 ** Math.max(0, failures - 1));
-  return Math.round(base * (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, "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.");
-    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: 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.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);
-    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). 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.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 if (this.cfg.behaviour === "localOnly") res = notFound(key);
-      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.urlOverrides)]);
-    if (this.cfg.behaviour !== "localOnly") {
-      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) 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;
-    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);
-}
-
-export {
-  decryptPayloadString,
-  stableStringify,
-  isEncryptedPayload,
-  isRemoteResults,
-  isFlagsPayload,
-  parseUrlOverrides,
-  createStaticFlags,
-  FLAGS_SDK_NAME,
-  FLAGS_SDK_VERSION,
-  DEFAULT_FLAGS_API_URL,
-  FlagsClient,
-  createFlagsClient
-};
-//# sourceMappingURL=chunk-ZTY7K7P2.js.map