@avsbhq/node 0.1.0

package/dist/index.cjs

@@ -0,0 +1,864 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  AvsBServer: () => AvsBServer,
+  InMemoryStickyBucketService: () => InMemoryStickyBucketService,
+  RedisStickyBucketService: () => RedisStickyBucketService,
+  SDK_VERSION: () => SDK_VERSION,
+  createDecisionLog: () => createDecisionLog,
+  createStreamingClient: () => createStreamingClient,
+  expressMiddleware: () => expressMiddleware,
+  fastifyPlugin: () => fastifyPlugin,
+  noopLogger: () => noopLogger
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/AvsBServer.ts
+var import_js = require("@avsbhq/js");
+
+// src/logger.ts
+var noopLogger = {
+  debug() {
+  },
+  info() {
+  },
+  warn() {
+  },
+  error() {
+  }
+};
+
+// src/decisionLog.ts
+function createDecisionLog() {
+  const entries = [];
+  return { entries };
+}
+
+// src/serverTracker.ts
+function createServerTracker(options) {
+  const {
+    sdkKey,
+    collectEndpoint,
+    flushInterval,
+    batchSize,
+    maxQueueSize,
+    retryAttempts,
+    logger
+  } = options;
+  const batchEndpoint = collectEndpoint.replace(/\/?$/, "/v1/collect/batch");
+  const metricEndpoint = collectEndpoint.replace(/\/?$/, "/v1/collect/metric-batch");
+  let exposureQueue = [];
+  let metricQueue = [];
+  let flushTimer = null;
+  let destroyed = false;
+  flushTimer = setInterval(() => {
+    flush().catch((e) => {
+      logger.error("Auto-flush error", { error: String(e) });
+    });
+  }, flushInterval);
+  function queue(event) {
+    if (destroyed) return;
+    exposureQueue.push(event);
+    if (exposureQueue.length > maxQueueSize) {
+      const dropped = exposureQueue.length - maxQueueSize;
+      exposureQueue = exposureQueue.slice(-maxQueueSize);
+      logger.warn(`Event queue full (${maxQueueSize}), dropping ${dropped} oldest events`);
+    }
+    if (exposureQueue.length >= batchSize) {
+      flush().catch((e) => {
+        logger.error("Batch-triggered flush error", { error: String(e) });
+      });
+    }
+  }
+  function queueMetric(event) {
+    if (destroyed) return;
+    metricQueue.push(event);
+    if (metricQueue.length > maxQueueSize) {
+      const dropped = metricQueue.length - maxQueueSize;
+      metricQueue = metricQueue.slice(-maxQueueSize);
+      logger.warn(`Metric queue full (${maxQueueSize}), dropping ${dropped} oldest events`);
+    }
+    if (metricQueue.length >= batchSize) {
+      flush().catch((e) => {
+        logger.error("Batch-triggered flush error", { error: String(e) });
+      });
+    }
+  }
+  async function flush() {
+    if (exposureQueue.length === 0 && metricQueue.length === 0) return;
+    const exposures = exposureQueue;
+    const metrics = metricQueue;
+    exposureQueue = [];
+    metricQueue = [];
+    const promises = [];
+    for (let i = 0; i < exposures.length; i += batchSize) {
+      const chunk = exposures.slice(i, i + batchSize);
+      promises.push(sendBatch(batchEndpoint, "events", chunk));
+    }
+    for (let i = 0; i < metrics.length; i += batchSize) {
+      const chunk = metrics.slice(i, i + batchSize);
+      promises.push(sendBatch(metricEndpoint, "metricEvents", chunk));
+    }
+    await Promise.all(promises);
+  }
+  async function sendBatch(endpoint, key, payload) {
+    const body = JSON.stringify({ sdkKey, [key]: payload });
+    for (let attempt = 0; attempt <= retryAttempts; attempt++) {
+      try {
+        const response = await fetch(endpoint, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body,
+          signal: AbortSignal.timeout(1e4)
+        });
+        if (!response.ok) {
+          throw new Error(`HTTP ${response.status}`);
+        }
+        logger.debug(`Flushed ${payload.length} events to ${endpoint}`);
+        return;
+      } catch (e) {
+        if (attempt < retryAttempts) {
+          const delay = 1e3 * Math.pow(2, attempt);
+          await new Promise((r) => setTimeout(r, delay));
+        } else {
+          logger.error(
+            `Failed to flush ${payload.length} events after ${retryAttempts} retries`,
+            { endpoint, error: String(e) }
+          );
+        }
+      }
+    }
+  }
+  async function destroy() {
+    destroyed = true;
+    if (flushTimer) {
+      clearInterval(flushTimer);
+      flushTimer = null;
+    }
+    await flush();
+  }
+  return { queue, queueMetric, flush, destroy };
+}
+
+// src/version.ts
+var SDK_VERSION = "0.1.0";
+
+// src/AvsBServer.ts
+var DEFAULT_EVENTS = {
+  flushInterval: 2e3,
+  batchSize: 10,
+  maxQueueSize: 1e4,
+  retryAttempts: 3
+};
+var AvsBServer = class {
+  sdkKey;
+  pollingInterval;
+  cdnHost;
+  initTimeout;
+  logger;
+  stickyBucketService;
+  eventOptions;
+  datafile;
+  ready;
+  destroyed;
+  tracker;
+  pollingId;
+  overrides = /* @__PURE__ */ new Map();
+  listeners = /* @__PURE__ */ new Map();
+  readyPromise = null;
+  constructor(options) {
+    this.sdkKey = options.sdkKey;
+    this.pollingInterval = Math.max(options.pollingInterval ?? 6e4, 5e3);
+    this.cdnHost = options.cdnHost ?? "https://cdn.avsb.app";
+    this.initTimeout = options.initTimeout ?? 1e4;
+    this.logger = options.logger ?? noopLogger;
+    this.stickyBucketService = options.stickyBucketService ?? null;
+    this.eventOptions = { ...DEFAULT_EVENTS, ...options.events };
+    this.datafile = options.bootstrap ?? null;
+    this.ready = !!options.bootstrap;
+    this.destroyed = false;
+    this.tracker = null;
+    this.pollingId = null;
+  }
+  onReady() {
+    if (this.readyPromise) return this.readyPromise;
+    this.readyPromise = this.initializeAndReady();
+    return this.readyPromise;
+  }
+  async initializeAndReady() {
+    if (this.ready && this.datafile) {
+      this.initTracker();
+      this.startPolling();
+      this.sendHeartbeat();
+      this.emit("ready");
+      return { success: true, source: "bootstrap" };
+    }
+    try {
+      const result = await Promise.race([
+        this.fetchDatafile().then((df) => ({ df, timedOut: false })),
+        new Promise(
+          (resolve) => setTimeout(() => resolve({ df: null, timedOut: true }), this.initTimeout)
+        )
+      ]);
+      if (result.timedOut) {
+        this.startPolling();
+        const error2 = new Error(`SDK initialization timed out after ${this.initTimeout}ms`);
+        this.emit("error", error2);
+        return { success: false, source: "timeout", error: error2 };
+      }
+      if (result.df) {
+        this.datafile = result.df;
+        this.initTracker();
+        this.ready = true;
+        this.startPolling();
+        this.sendHeartbeat();
+        this.emit("ready");
+        return { success: true, source: "network" };
+      }
+      this.startPolling();
+      const error = new Error("Failed to fetch datafile");
+      this.emit("error", error);
+      return { success: false, source: "error", error };
+    } catch (e) {
+      this.startPolling();
+      const error = e instanceof Error ? e : new Error(String(e));
+      this.emit("error", error);
+      return { success: false, source: "error", error };
+    }
+  }
+  async close() {
+    this.destroyed = true;
+    if (this.pollingId) {
+      clearInterval(this.pollingId);
+      this.pollingId = null;
+    }
+    if (this.tracker) {
+      await this.tracker.destroy();
+      this.tracker = null;
+    }
+    this.datafile = null;
+    this.ready = false;
+  }
+  async flush() {
+    if (this.tracker) await this.tracker.flush();
+  }
+  async refreshDatafile() {
+    const df = await this.fetchDatafile();
+    if (!df) {
+      this.logger.warn("Datafile refresh failed, keeping current datafile");
+      return;
+    }
+    const changed = !this.datafile || this.datafile.publishedAt !== df.publishedAt;
+    this.datafile = df;
+    if (!this.ready) {
+      this.initTracker();
+      this.ready = true;
+      this.emit("ready");
+    } else if (changed) {
+      this.emit("configUpdate", { publishedAt: df.publishedAt });
+      this.logger.info("Datafile updated", { publishedAt: df.publishedAt });
+    }
+  }
+  getFlag(flagKey, userContext, defaultValue) {
+    if (!this.ready || !this.datafile) {
+      this.logger.debug(`SDK not ready, returning default for ${flagKey}`);
+      return defaultValue;
+    }
+    const result = this.evaluate(flagKey, userContext, defaultValue);
+    this.emitEvaluation(flagKey, result.value, userContext.userId, result.source);
+    return result.value ?? defaultValue;
+  }
+  getFlagDetails(flagKey, userContext) {
+    if (!this.ready || !this.datafile) {
+      return {
+        value: void 0,
+        variationKey: null,
+        source: "not_found",
+        ruleId: null,
+        ruleType: null,
+        flagKey,
+        reasons: ["SDK not ready"]
+      };
+    }
+    const r = this.evaluate(flagKey, userContext, void 0);
+    return {
+      value: r.value,
+      variationKey: r.variationKey,
+      source: r.source,
+      ruleId: r.ruleId,
+      ruleType: r.ruleType,
+      flagKey,
+      reasons: r.reasons
+    };
+  }
+  getAllFlags(userContext) {
+    if (!this.ready || !this.datafile) return {};
+    const out = {};
+    for (const flag of this.datafile.flags) out[flag.key] = this.getFlag(flag.key, userContext);
+    return out;
+  }
+  track(eventKey, context) {
+    if (!this.ready || !this.tracker) {
+      this.logger.warn(`SDK not ready, dropping track event "${eventKey}"`);
+      return;
+    }
+    this.tracker.queueMetric({
+      visitorId: context.userId,
+      eventName: eventKey,
+      revenue: context.revenue ?? null,
+      timestamp: Date.now(),
+      pageUrl: ""
+    });
+  }
+  logExposure(flagKey, userContext) {
+    if (!this.ready || !this.datafile || !this.tracker) return;
+    const ctx = { attributes: { userId: userContext.userId } };
+    const result = (0, import_js.evaluateFlag)(flagKey, void 0, ctx, this.datafile);
+    if (result.source !== "rule" || !result.ruleId) return;
+    const flag = this.datafile.flags.find((f) => f.key === flagKey);
+    if (!flag) return;
+    const rule = flag.rules.find((r) => r.id === result.ruleId);
+    if (!rule || rule.type !== "ab_test") return;
+    const rv = rule.variations.find((v) => {
+      const fv = flag.variations.find((x) => x.id === v.variationId);
+      return fv?.key === result.variationKey;
+    });
+    if (!rv) return;
+    this.tracker.queue({
+      visitorId: userContext.userId,
+      experimentId: result.ruleId,
+      variationId: rv.variationId,
+      eventName: "flag_exposure",
+      revenue: null,
+      timestamp: Date.now(),
+      pageUrl: "",
+      properties: { flagKey, flagId: flag.id }
+    });
+  }
+  setOverride(flagKey, variationKey, userId) {
+    if (!this.overrides.has(flagKey)) this.overrides.set(flagKey, /* @__PURE__ */ new Map());
+    this.overrides.get(flagKey).set(userId ?? "*", variationKey);
+  }
+  clearOverride(flagKey, userId) {
+    const m = this.overrides.get(flagKey);
+    if (!m) return;
+    m.delete(userId ?? "*");
+    if (m.size === 0) this.overrides.delete(flagKey);
+  }
+  clearAllOverrides() {
+    this.overrides.clear();
+  }
+  createDecisionLog() {
+    return createDecisionLog();
+  }
+  on(event, cb) {
+    if (!this.listeners.has(event)) this.listeners.set(event, /* @__PURE__ */ new Set());
+    this.listeners.get(event).add(cb);
+  }
+  off(event, cb) {
+    this.listeners.get(event)?.delete(cb);
+  }
+  evaluate(flagKey, uc, defaultValue) {
+    const startTime = Date.now();
+    const reasons = [];
+    const rtOver = this.resolveRuntimeOverride(flagKey, uc.userId);
+    if (rtOver !== void 0) {
+      reasons.push(`matched runtime override for flagKey="${flagKey}"`);
+      this.recordDecisionLog(uc, {
+        flagKey,
+        value: rtOver.value,
+        variationKey: rtOver.key,
+        source: "runtime_override",
+        ruleId: null,
+        ruleType: null,
+        reasons,
+        startTime
+      });
+      return {
+        value: rtOver.value,
+        variationKey: rtOver.key,
+        source: "runtime_override",
+        ruleId: null,
+        ruleType: null,
+        reasons
+      };
+    }
+    if (this.stickyBucketService) {
+      const sticky = this.resolveStickyBucket(flagKey, uc.userId);
+      if (sticky !== void 0) {
+        reasons.push(`matched sticky bucket assignment for userId="${uc.userId}"`);
+        if (!uc.suppressExposure) this.fireExposureForVariation(flagKey, sticky, uc);
+        this.recordDecisionLog(uc, {
+          flagKey,
+          value: sticky.value,
+          variationKey: sticky.key,
+          source: "sticky",
+          ruleId: null,
+          ruleType: null,
+          reasons,
+          startTime
+        });
+        return {
+          value: sticky.value,
+          variationKey: sticky.key,
+          source: "sticky",
+          ruleId: null,
+          ruleType: null,
+          reasons
+        };
+      }
+    }
+    const context = { attributes: { userId: uc.userId, ...uc.attributes } };
+    const shouldFire = !uc.suppressExposure && !uc.decisionLog?.entries.some(
+      (e) => e.flagKey === flagKey && e.source !== "not_found" && e.source !== "disabled"
+    );
+    const onExposure = shouldFire ? (event) => {
+      if (uc.privateAttributes?.length && event.properties) {
+        const cleaned = { ...event.properties };
+        for (const k of uc.privateAttributes) delete cleaned[k];
+        event = { ...event, properties: cleaned };
+      }
+      this.tracker?.queue(event);
+    } : void 0;
+    const r = (0, import_js.evaluateFlag)(flagKey, defaultValue, context, this.datafile, onExposure, reasons);
+    if (this.stickyBucketService && r.variationKey) {
+      const v = this.findVariation(flagKey, r.variationKey);
+      if (v) this.stickyBucketService.save(uc.userId, flagKey, v.id);
+    }
+    this.recordDecisionLog(uc, {
+      flagKey,
+      value: r.value,
+      variationKey: r.variationKey,
+      source: r.source,
+      ruleId: r.ruleId,
+      ruleType: r.ruleType,
+      reasons,
+      startTime
+    });
+    return {
+      value: r.value,
+      variationKey: r.variationKey,
+      source: r.source,
+      ruleId: r.ruleId,
+      ruleType: r.ruleType,
+      reasons
+    };
+  }
+  emit(event, ...args) {
+    const cbs = this.listeners.get(event);
+    if (!cbs) return;
+    for (const cb of cbs) {
+      try {
+        cb(...args);
+      } catch (e) {
+        this.logger.error("Listener error", { event, error: String(e) });
+      }
+    }
+  }
+  initTracker() {
+    if (!this.datafile || this.tracker) return;
+    this.tracker = createServerTracker({
+      sdkKey: this.sdkKey,
+      collectEndpoint: this.datafile.collectEndpoint,
+      flushInterval: this.eventOptions.flushInterval,
+      batchSize: this.eventOptions.batchSize,
+      maxQueueSize: this.eventOptions.maxQueueSize,
+      retryAttempts: this.eventOptions.retryAttempts,
+      logger: this.logger
+    });
+  }
+  async fetchDatafile() {
+    const url = `${this.cdnHost}/${this.sdkKey}/datafile.json`;
+    try {
+      const res = await fetch(url, { signal: AbortSignal.timeout(1e4) });
+      if (!res.ok) {
+        this.logger.warn("Datafile fetch failed", { status: res.status, url });
+        return null;
+      }
+      return await res.json();
+    } catch (e) {
+      this.logger.warn("Datafile fetch error", { error: String(e), url });
+      return null;
+    }
+  }
+  startPolling() {
+    if (this.pollingId || this.destroyed) return;
+    this.pollingId = setInterval(async () => {
+      const df = await this.fetchDatafile();
+      if (!df) return;
+      const changed = !this.datafile || this.datafile.publishedAt !== df.publishedAt;
+      if (!this.ready) {
+        this.datafile = df;
+        this.initTracker();
+        this.ready = true;
+        this.emit("ready");
+      } else if (changed) {
+        this.datafile = df;
+        this.emit("configUpdate", { publishedAt: df.publishedAt });
+        this.logger.info("Datafile updated", { publishedAt: df.publishedAt });
+      }
+    }, this.pollingInterval);
+  }
+  sendHeartbeat() {
+    if (!this.datafile?.heartbeatEndpoint) return;
+    fetch(this.datafile.heartbeatEndpoint, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ sdkKey: this.sdkKey, sdkType: "@avsbhq/node", sdkVersion: SDK_VERSION })
+    }).catch(() => {
+    });
+  }
+  resolveRuntimeOverride(flagKey, userId) {
+    const m = this.overrides.get(flagKey);
+    if (!m) return void 0;
+    const vk = m.get(userId) ?? m.get("*");
+    if (!vk) return void 0;
+    return this.findVariation(flagKey, vk) ?? void 0;
+  }
+  resolveStickyBucket(flagKey, userId) {
+    if (!this.stickyBucketService || !this.datafile) return void 0;
+    const vid = this.stickyBucketService.lookup(userId, flagKey);
+    if (!vid) return void 0;
+    const flag = this.datafile.flags.find((f) => f.key === flagKey);
+    if (!flag) return void 0;
+    const v = flag.variations.find((x) => x.id === vid);
+    if (!v) return void 0;
+    return { value: v.value, key: v.key, id: v.id };
+  }
+  findVariation(flagKey, variationKey) {
+    if (!this.datafile) return null;
+    const flag = this.datafile.flags.find((f) => f.key === flagKey);
+    if (!flag) return null;
+    const v = flag.variations.find((x) => x.key === variationKey);
+    if (!v) return null;
+    return { value: v.value, key: v.key, id: v.id };
+  }
+  fireExposureForVariation(flagKey, vr, uc) {
+    if (!this.tracker || !this.datafile) return;
+    const flag = this.datafile.flags.find((f) => f.key === flagKey);
+    if (!flag) return;
+    for (const rule of flag.rules) {
+      if (rule.type !== "ab_test") continue;
+      if (rule.variations.some((rv) => rv.variationId === vr.id)) {
+        this.tracker.queue({
+          visitorId: uc.userId,
+          experimentId: rule.id,
+          variationId: vr.id,
+          eventName: "flag_exposure",
+          revenue: null,
+          timestamp: Date.now(),
+          pageUrl: "",
+          properties: { flagKey, flagId: flag.id }
+        });
+        return;
+      }
+    }
+  }
+  recordDecisionLog(uc, d) {
+    if (!uc.decisionLog) return;
+    uc.decisionLog.entries.push({
+      flagKey: d.flagKey,
+      value: d.value,
+      variationKey: d.variationKey,
+      source: d.source,
+      ruleId: d.ruleId,
+      ruleType: d.ruleType,
+      reasons: [...d.reasons],
+      evaluatedAt: d.startTime,
+      durationMs: Date.now() - d.startTime
+    });
+  }
+  emitEvaluation(flagKey, value, userId, source) {
+    this.emit("evaluation", { flagKey, value, userId, source });
+  }
+};
+
+// src/middleware.ts
+function createNoopRequestAvsB() {
+  return {
+    getFlag(_flagKey, defaultValue) {
+      return defaultValue;
+    },
+    getFlagDetails(flagKey) {
+      return {
+        value: void 0,
+        variationKey: null,
+        source: "not_found",
+        ruleId: null,
+        ruleType: null,
+        flagKey,
+        reasons: ["no userId available"]
+      };
+    },
+    getAllFlags() {
+      return {};
+    },
+    track() {
+    }
+  };
+}
+function expressMiddleware(client, config) {
+  return (req, res, next) => {
+    const userId = config.userIdFrom(req);
+    if (!userId) {
+      ;
+      req.avsb = createNoopRequestAvsB();
+      return next();
+    }
+    const attributes = config.attributesFrom?.(req) ?? {};
+    const baseContext = { userId, attributes };
+    req.avsb = {
+      getFlag(flagKey, defaultValue) {
+        return client.getFlag(flagKey, baseContext, defaultValue);
+      },
+      getFlagDetails(flagKey) {
+        return client.getFlagDetails(flagKey, baseContext);
+      },
+      getAllFlags() {
+        return client.getAllFlags(baseContext);
+      },
+      track(eventKey, properties) {
+        client.track(eventKey, { userId, revenue: properties?.revenue, properties });
+      }
+    };
+    next();
+  };
+}
+function fastifyPlugin(instance, opts, done) {
+  const fastify = instance;
+  fastify.decorateRequest("avsb", null);
+  fastify.addHook("onRequest", (...args) => {
+    const req = args[0];
+    const hookDone = args[2];
+    const userId = opts.userIdFrom(req);
+    if (!userId) {
+      ;
+      req.avsb = createNoopRequestAvsB();
+      return hookDone();
+    }
+    const attributes = opts.attributesFrom?.(req) ?? {};
+    const baseContext = { userId, attributes };
+    req.avsb = {
+      getFlag(flagKey, defaultValue) {
+        return opts.client.getFlag(flagKey, baseContext, defaultValue);
+      },
+      getFlagDetails(flagKey) {
+        return opts.client.getFlagDetails(flagKey, baseContext);
+      },
+      getAllFlags() {
+        return opts.client.getAllFlags(baseContext);
+      },
+      track(eventKey, properties) {
+        opts.client.track(eventKey, { userId, revenue: properties?.revenue, properties });
+      }
+    };
+    hookDone();
+  });
+  done();
+}
+
+// src/stickyBucket.ts
+var InMemoryStickyBucketService = class {
+  cache = /* @__PURE__ */ new Map();
+  key(userId, flagKey) {
+    return `${userId}:${flagKey}`;
+  }
+  lookup(userId, flagKey) {
+    return this.cache.get(this.key(userId, flagKey)) ?? null;
+  }
+  save(userId, flagKey, variationId) {
+    this.cache.set(this.key(userId, flagKey), variationId);
+  }
+};
+var RedisStickyBucketService = class {
+  redis;
+  prefix;
+  ttl;
+  maxCacheSize;
+  logger;
+  cache = /* @__PURE__ */ new Map();
+  constructor(options) {
+    this.redis = options.redis;
+    this.prefix = options.prefix ?? "avsb:sticky:";
+    this.ttl = options.ttl ?? 2592e3;
+    this.maxCacheSize = options.cacheSize ?? 1e4;
+    this.logger = options.logger ?? noopLogger;
+  }
+  redisKey(userId, flagKey) {
+    return `${this.prefix}${userId}:${flagKey}`;
+  }
+  cacheKey(userId, flagKey) {
+    return `${userId}:${flagKey}`;
+  }
+  lookup(userId, flagKey) {
+    const ck = this.cacheKey(userId, flagKey);
+    const cached = this.cache.get(ck);
+    if (cached !== void 0) return cached;
+    this.backgroundFetch(userId, flagKey);
+    return null;
+  }
+  save(userId, flagKey, variationId) {
+    const ck = this.cacheKey(userId, flagKey);
+    this.cache.set(ck, variationId);
+    this.evictIfNeeded();
+    const rk = this.redisKey(userId, flagKey);
+    this.redis.set(rk, variationId, { EX: this.ttl }).catch((e) => {
+      this.logger.error("Redis sticky bucket save failed", {
+        key: rk,
+        error: String(e)
+      });
+    });
+  }
+  backgroundFetch(userId, flagKey) {
+    const rk = this.redisKey(userId, flagKey);
+    const ck = this.cacheKey(userId, flagKey);
+    this.redis.get(rk).then((value) => {
+      if (value !== null) {
+        this.cache.set(ck, value);
+        this.evictIfNeeded();
+      }
+    }).catch((e) => {
+      this.logger.error("Redis sticky bucket fetch failed", {
+        key: rk,
+        error: String(e)
+      });
+    });
+  }
+  evictIfNeeded() {
+    if (this.cache.size <= this.maxCacheSize) return;
+    const firstKey = this.cache.keys().next().value;
+    if (firstKey !== void 0) {
+      this.cache.delete(firstKey);
+    }
+  }
+};
+
+// src/streaming.ts
+function createStreamingClient(options) {
+  const {
+    endpoint,
+    sdkKey,
+    onDatafileUpdated,
+    logger,
+    reconnectDelay = 5e3
+  } = options;
+  let connected = false;
+  let abortController = null;
+  let reconnectTimer = null;
+  function connect() {
+    if (connected) return;
+    startConnection();
+  }
+  function disconnect() {
+    connected = false;
+    if (abortController) {
+      abortController.abort();
+      abortController = null;
+    }
+    if (reconnectTimer) {
+      clearTimeout(reconnectTimer);
+      reconnectTimer = null;
+    }
+  }
+  function isConnected() {
+    return connected;
+  }
+  async function startConnection() {
+    abortController = new AbortController();
+    const url = `${endpoint}?sdkKey=${encodeURIComponent(sdkKey)}`;
+    try {
+      const response = await fetch(url, {
+        headers: { Accept: "text/event-stream" },
+        signal: abortController.signal
+      });
+      if (!response.ok) {
+        logger.warn("SSE connection failed", { status: response.status, url });
+        scheduleReconnect();
+        return;
+      }
+      if (!response.body) {
+        logger.warn("SSE response has no body");
+        scheduleReconnect();
+        return;
+      }
+      connected = true;
+      logger.info(`SSE connected to ${endpoint}`);
+      const reader = response.body.getReader();
+      const decoder = new TextDecoder();
+      let buffer = "";
+      try {
+        while (true) {
+          const { done, value } = await reader.read();
+          if (done) break;
+          buffer += decoder.decode(value, { stream: true });
+          const lines = buffer.split("\n");
+          buffer = lines.pop() ?? "";
+          for (const line of lines) {
+            if (line.startsWith("data: ")) {
+              const data = line.slice(6).trim();
+              if (!data) continue;
+              try {
+                const parsed = JSON.parse(data);
+                if (parsed.type === "datafile_updated") {
+                  onDatafileUpdated();
+                }
+              } catch {
+                logger.warn("Failed to parse SSE data", { data });
+              }
+            }
+          }
+        }
+      } catch (e) {
+        if (abortController?.signal.aborted) return;
+        logger.warn("SSE stream read error", { error: String(e) });
+      }
+      connected = false;
+      logger.warn(`SSE disconnected, reconnecting in ${reconnectDelay}ms`);
+      scheduleReconnect();
+    } catch (e) {
+      if (abortController?.signal.aborted) return;
+      logger.warn("SSE connection error", { error: String(e) });
+      connected = false;
+      scheduleReconnect();
+    }
+  }
+  function scheduleReconnect() {
+    if (reconnectTimer) return;
+    reconnectTimer = setTimeout(() => {
+      reconnectTimer = null;
+      startConnection();
+    }, reconnectDelay);
+  }
+  return { connect, disconnect, isConnected };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AvsBServer,
+  InMemoryStickyBucketService,
+  RedisStickyBucketService,
+  SDK_VERSION,
+  createDecisionLog,
+  createStreamingClient,
+  expressMiddleware,
+  fastifyPlugin,
+  noopLogger
+});