@avsbhq/node 0.3.0 → 1.0.0

package/dist/index.cjs

@@ -20,32 +20,25 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
-  AvsBServer: () => AvsBServer,
+  AvsbServer: () => AvsbServer,
+  DecideOption: () => import_core4.DecideOption,
   InMemoryStickyBucketService: () => InMemoryStickyBucketService,
   RedisStickyBucketService: () => RedisStickyBucketService,
   SDK_VERSION: () => SDK_VERSION,
+  consoleLogger: () => import_core3.consoleLogger,
+  consoleTransport: () => import_core3.consoleTransport,
   createDecisionLog: () => createDecisionLog,
+  createLogger: () => import_core3.createLogger,
   createStreamingClient: () => createStreamingClient,
   expressMiddleware: () => expressMiddleware,
   fastifyPlugin: () => fastifyPlugin,
-  noopLogger: () => noopLogger
+  noopLogger: () => import_core3.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/AvsbServer.ts
+var import_engine = require("@avsbhq/core/engine");
+var import_core2 = require("@avsbhq/core");
 
 // src/decisionLog.ts
 function createDecisionLog() {
@@ -53,6 +46,33 @@ function createDecisionLog() {
   return { entries };
 }
 
+// src/reconnectBackoff.ts
+var BASE_DELAY_MS = 1e3;
+var MAX_DELAY_MS = 6e4;
+var MIN_DELAY_MS = 500;
+var JITTER = 0.2;
+function nextBackoff(prev, retryAfterMs) {
+  const attempt = (prev?.attempt ?? 0) + 1;
+  if (typeof retryAfterMs === "number" && retryAfterMs > 0) {
+    return { attempt, delayMs: retryAfterMs };
+  }
+  const base = Math.min(MAX_DELAY_MS, BASE_DELAY_MS * 2 ** (attempt - 1));
+  const jitter = base * JITTER * (Math.random() * 2 - 1);
+  const delayMs = Math.max(MIN_DELAY_MS, Math.round(base + jitter));
+  return { attempt, delayMs };
+}
+function resetBackoff() {
+  return null;
+}
+function parseRetryAfter(headerValue) {
+  if (!headerValue) return null;
+  const trimmed = headerValue.trim();
+  if (!trimmed) return null;
+  const n = Number(trimmed);
+  if (!Number.isFinite(n) || n < 0) return null;
+  return Math.round(n * 1e3);
+}
+
 // src/serverTracker.ts
 function createServerTracker(options) {
   const {
@@ -122,6 +142,8 @@ function createServerTracker(options) {
   }
   async function sendBatch(endpoint, key, payload) {
     const body = JSON.stringify({ sdkKey, [key]: payload });
+    let backoff = resetBackoff();
+    let pendingRetryAfterMs = void 0;
     for (let attempt = 0; attempt <= retryAttempts; attempt++) {
       try {
         const response = await fetch(endpoint, {
@@ -131,14 +153,17 @@ function createServerTracker(options) {
           signal: AbortSignal.timeout(1e4)
         });
         if (!response.ok) {
+          const parsed = parseRetryAfter(response.headers.get("retry-after"));
+          if (parsed !== null) pendingRetryAfterMs = parsed;
           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));
+          backoff = nextBackoff(backoff, pendingRetryAfterMs);
+          pendingRetryAfterMs = void 0;
+          await new Promise((r) => setTimeout(r, backoff.delayMs));
         } else {
           logger.error(
             `Failed to flush ${payload.length} events after ${retryAttempts} retries`,
@@ -159,17 +184,308 @@ function createServerTracker(options) {
   return { queue, queueMetric, flush, destroy };
 }
 
+// src/streaming.ts
+function createStreamingClient(options) {
+  const {
+    endpoint,
+    sdkKey,
+    onDatafileUpdated,
+    logger,
+    reconnectDelay
+  } = options;
+  let connected = false;
+  let abortController = null;
+  let reconnectTimer = null;
+  let backoff = resetBackoff();
+  let pendingRetryAfterMs = void 0;
+  function connect() {
+    if (connected) return;
+    void startConnection();
+  }
+  function disconnect() {
+    connected = false;
+    if (abortController) {
+      abortController.abort();
+      abortController = null;
+    }
+    if (reconnectTimer) {
+      clearTimeout(reconnectTimer);
+      reconnectTimer = null;
+    }
+  }
+  function isConnected() {
+    return connected;
+  }
+  async function fetchTicket(signal) {
+    const ticketUrl = `${endpoint}?sdkKey=${encodeURIComponent(sdkKey)}`;
+    try {
+      const res = await fetch(ticketUrl, { signal });
+      if (!res.ok) {
+        logger.warn("SSE ticket fetch failed", { status: res.status, url: ticketUrl });
+        return null;
+      }
+      const body = await res.json();
+      if (!body?.url || !body?.token) {
+        logger.warn("SSE ticket response missing fields");
+        return null;
+      }
+      return body;
+    } catch (e) {
+      if (signal.aborted) return null;
+      logger.warn("SSE ticket fetch error", { error: String(e) });
+      return null;
+    }
+  }
+  async function startConnection() {
+    abortController = new AbortController();
+    const signal = abortController.signal;
+    const ticket = await fetchTicket(signal);
+    if (!ticket || signal.aborted) {
+      if (!signal.aborted) scheduleReconnect();
+      return;
+    }
+    const streamUrl = `${ticket.url}?sdkKey=${encodeURIComponent(sdkKey)}&token=${encodeURIComponent(ticket.token)}`;
+    try {
+      const response = await fetch(streamUrl, {
+        headers: { Accept: "text/event-stream" },
+        signal
+      });
+      if (response.status === 401) {
+        logger.warn("SSE stream rejected token; refetching ticket");
+        const next = await fetchTicket(signal);
+        if (!next || signal.aborted) {
+          if (!signal.aborted) scheduleReconnect();
+          return;
+        }
+        const retryUrl = `${next.url}?sdkKey=${encodeURIComponent(sdkKey)}&token=${encodeURIComponent(next.token)}`;
+        const retry = await fetch(retryUrl, {
+          headers: { Accept: "text/event-stream" },
+          signal
+        });
+        if (!retry.ok || !retry.body) {
+          logger.warn("SSE retry failed", { status: retry.status });
+          recordRetryAfter(retry.headers.get("retry-after"));
+          scheduleReconnect();
+          return;
+        }
+        await pumpFrames(retry, signal);
+        return;
+      }
+      if (response.status === 429) {
+        recordRetryAfter(response.headers.get("retry-after"));
+        logger.warn("SSE rate-limited", { status: 429 });
+        scheduleReconnect();
+        return;
+      }
+      if (!response.ok) {
+        logger.warn("SSE connection failed", { status: response.status, url: streamUrl });
+        recordRetryAfter(response.headers.get("retry-after"));
+        scheduleReconnect();
+        return;
+      }
+      if (!response.body) {
+        logger.warn("SSE response has no body");
+        scheduleReconnect();
+        return;
+      }
+      await pumpFrames(response, signal);
+    } catch (e) {
+      if (signal.aborted) return;
+      logger.warn("SSE connection error", { error: String(e) });
+      connected = false;
+      scheduleReconnect();
+    }
+  }
+  function recordRetryAfter(headerValue) {
+    const parsed = parseRetryAfter(headerValue);
+    if (parsed !== null) pendingRetryAfterMs = parsed;
+  }
+  async function pumpFrames(response, signal) {
+    connected = true;
+    backoff = resetBackoff();
+    pendingRetryAfterMs = void 0;
+    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 (signal.aborted) return;
+      logger.warn("SSE stream read error", { error: String(e) });
+    }
+    connected = false;
+    scheduleReconnect();
+  }
+  function scheduleReconnect() {
+    if (reconnectTimer) return;
+    if (typeof reconnectDelay === "number") {
+      reconnectTimer = setTimeout(() => {
+        reconnectTimer = null;
+        void startConnection();
+      }, reconnectDelay);
+      return;
+    }
+    backoff = nextBackoff(backoff, pendingRetryAfterMs);
+    pendingRetryAfterMs = void 0;
+    logger.warn(
+      `SSE reconnect attempt ${backoff.attempt} in ${backoff.delayMs}ms`
+    );
+    reconnectTimer = setTimeout(() => {
+      reconnectTimer = null;
+      void startConnection();
+    }, backoff.delayMs);
+  }
+  return { connect, disconnect, isConnected };
+}
+
 // src/version.ts
 var SDK_VERSION = "0.3.0";
 
-// src/AvsBServer.ts
+// src/UserBoundClient.ts
+function createUserBoundClient(server, context) {
+  const decisionLog = createDecisionLog();
+  const forcedDecisions = /* @__PURE__ */ new Map();
+  function buildOptions(options) {
+    return {
+      context,
+      decideOptions: options?.decideOptions,
+      decisionLog
+    };
+  }
+  return {
+    getFlag(flagKey, defaultValue, options) {
+      const forced = forcedDecisions.get(flagKey);
+      if (forced) {
+        return server.getFlag(flagKey, defaultValue, {
+          ...buildOptions(options),
+          forcedVariationKey: forced.variationKey
+        });
+      }
+      return server.getFlag(flagKey, defaultValue, buildOptions(options));
+    },
+    getBoolFlag(flagKey, defaultValue, options) {
+      const forced = forcedDecisions.get(flagKey);
+      if (forced) {
+        return server.getBoolFlag(flagKey, defaultValue, {
+          ...buildOptions(options),
+          forcedVariationKey: forced.variationKey
+        });
+      }
+      return server.getBoolFlag(flagKey, defaultValue, buildOptions(options));
+    },
+    getStringFlag(flagKey, defaultValue, options) {
+      const forced = forcedDecisions.get(flagKey);
+      if (forced) {
+        return server.getStringFlag(flagKey, defaultValue, {
+          ...buildOptions(options),
+          forcedVariationKey: forced.variationKey
+        });
+      }
+      return server.getStringFlag(flagKey, defaultValue, buildOptions(options));
+    },
+    getNumberFlag(flagKey, defaultValue, options) {
+      const forced = forcedDecisions.get(flagKey);
+      if (forced) {
+        return server.getNumberFlag(flagKey, defaultValue, {
+          ...buildOptions(options),
+          forcedVariationKey: forced.variationKey
+        });
+      }
+      return server.getNumberFlag(flagKey, defaultValue, buildOptions(options));
+    },
+    getJsonFlag(flagKey, defaultValue, options) {
+      const forced = forcedDecisions.get(flagKey);
+      if (forced) {
+        return server.getJsonFlag(flagKey, defaultValue, {
+          ...buildOptions(options),
+          forcedVariationKey: forced.variationKey
+        });
+      }
+      return server.getJsonFlag(flagKey, defaultValue, buildOptions(options));
+    },
+    getAllFlags(options) {
+      return server.getAllFlags(context, options);
+    },
+    track(eventKey, payload) {
+      server.track(eventKey, { ...payload, context });
+    },
+    setForcedDecision(flagKey, opts) {
+      forcedDecisions.set(flagKey, opts);
+    },
+    clearForcedDecision(flagKey) {
+      forcedDecisions.delete(flagKey);
+    },
+    getDecisionLog() {
+      return decisionLog;
+    }
+  };
+}
+
+// src/utils.ts
+var import_utils = require("@avsbhq/utils");
+var import_core = require("@avsbhq/core");
+function buildServerUtils(server) {
+  const adapter = {
+    getFlag(flagKey, defaultValue) {
+      return (0, import_core.notFoundFlag)(defaultValue, "no bound context");
+    },
+    getAllFlags(opts) {
+      const ctx = opts?.context;
+      if (!ctx) return {};
+      return server.getAllFlags(ctx, {
+        fireExposures: opts.fireExposures
+      });
+    },
+    track(eventKey, payload) {
+      if (!payload?.context) return;
+      server.track(eventKey, {
+        ...payload,
+        context: payload.context
+      });
+    },
+    on(event, cb) {
+      return server.on(event, cb);
+    },
+    getDatafile: () => server.getDatafile(),
+    getCurrentContext: () => null,
+    applyDatafile() {
+    },
+    applySnapshot() {
+    }
+  };
+  return (0, import_utils.createUtils)(adapter);
+}
+
+// src/AvsbServer.ts
 var DEFAULT_EVENTS = {
   flushInterval: 2e3,
   batchSize: 10,
   maxQueueSize: 1e4,
   retryAttempts: 3
 };
-var AvsBServer = class {
+var DEFAULT_STREAMING_ENDPOINT = "https://app.avsb.cloud/api/sdk/stream";
+var AvsbServer = class {
   sdkKey;
   pollingInterval;
   cdnHost;
@@ -177,29 +493,70 @@ var AvsBServer = class {
   logger;
   stickyBucketService;
   eventOptions;
+  streamingEnabled;
+  streamingEndpoint;
   datafile;
   ready;
   destroyed;
   tracker;
+  streamingClient;
   pollingId;
+  abortController = new AbortController();
   overrides = /* @__PURE__ */ new Map();
   listeners = /* @__PURE__ */ new Map();
   readyPromise = null;
+  pendingEvents = [];
+  /**
+   * §6 — `client.utils.*` surface. Constructed lazily on first access so
+   * the utils package is only imported when actually consumed.
+   *
+   * The server's event surface (`ServerEventMap`) is a subset of the
+   * shared `ClientEventMap`; the utils-adapter `on` here ignores events
+   * the server doesn't emit (e.g. `flagChange`). Workstream 5 (CoW 6)
+   * harmonises the two maps when the streaming evaluator lands.
+   */
+  _utils = null;
+  get utils() {
+    if (!this._utils) {
+      this._utils = buildServerUtils({
+        getAllFlags: (ctx, opts) => this.getAllFlags(ctx, opts),
+        getFlag: (flagKey, defaultValue, opts) => this.getFlag(flagKey, defaultValue, opts),
+        track: (eventKey, payload) => this.track(eventKey, payload),
+        on: (event, cb) => {
+          if (event === "ready" || event === "configUpdate" || event === "evaluation" || event === "error" || event === "stickyOrphan") {
+            return this.on(
+              event,
+              cb
+            );
+          }
+          return () => void 0;
+        },
+        getDatafile: () => this.datafile
+      });
+    }
+    return this._utils;
+  }
   constructor(options) {
     this.sdkKey = options.sdkKey;
     this.pollingInterval = Math.max(options.pollingInterval ?? 6e4, 5e3);
     const rawCdnHost = options.cdnHost ?? "https://cdn.avsb.cloud";
     this.cdnHost = rawCdnHost.endsWith("/") ? rawCdnHost.slice(0, -1) : rawCdnHost;
     this.initTimeout = options.initTimeout ?? 1e4;
-    this.logger = options.logger ?? noopLogger;
+    this.logger = options.logger ?? import_core2.noopLogger;
     this.stickyBucketService = options.stickyBucketService ?? null;
     this.eventOptions = { ...DEFAULT_EVENTS, ...options.events };
+    this.streamingEnabled = options.streaming ?? false;
+    this.streamingEndpoint = options.streamingEndpoint ?? DEFAULT_STREAMING_ENDPOINT;
     this.datafile = options.bootstrap ?? null;
     this.ready = !!options.bootstrap;
     this.destroyed = false;
     this.tracker = null;
+    this.streamingClient = null;
     this.pollingId = null;
   }
+  // ---------------------------------------------------------------------------
+  // §5.4 onReady — never rejects, always resolves to InitResult
+  // ---------------------------------------------------------------------------
   onReady() {
     if (this.readyPromise) return this.readyPromise;
     this.readyPromise = this.initializeAndReady();
@@ -209,6 +566,7 @@ var AvsBServer = class {
     if (this.ready && this.datafile) {
       this.initTracker();
       this.startPolling();
+      this.startStreamingIfEnabled();
       this.sendHeartbeat();
       this.emit("ready");
       return { success: true, source: "bootstrap" };
@@ -222,6 +580,7 @@ var AvsBServer = class {
       ]);
       if (result.timedOut) {
         this.startPolling();
+        this.startStreamingIfEnabled();
         const error2 = new Error(`SDK initialization timed out after ${this.initTimeout}ms`);
         this.emit("error", error2);
         return { success: false, source: "timeout", error: error2 };
@@ -231,23 +590,34 @@ var AvsBServer = class {
         this.initTracker();
         this.ready = true;
         this.startPolling();
+        this.startStreamingIfEnabled();
         this.sendHeartbeat();
         this.emit("ready");
         return { success: true, source: "network" };
       }
       this.startPolling();
+      this.startStreamingIfEnabled();
       const error = new Error("Failed to fetch datafile");
       this.emit("error", error);
       return { success: false, source: "error", error };
     } catch (e) {
       this.startPolling();
+      this.startStreamingIfEnabled();
       const error = e instanceof Error ? e : new Error(String(e));
       this.emit("error", error);
       return { success: false, source: "error", error };
     }
   }
+  // ---------------------------------------------------------------------------
+  // Lifecycle
+  // ---------------------------------------------------------------------------
   async close() {
     this.destroyed = true;
+    this.abortController.abort();
+    if (this.streamingClient) {
+      this.streamingClient.disconnect();
+      this.streamingClient = null;
+    }
     if (this.pollingId) {
       clearInterval(this.pollingId);
       this.pollingId = null;
@@ -256,6 +626,7 @@ var AvsBServer = class {
       await this.tracker.destroy();
       this.tracker = null;
     }
+    this._utils?._drain();
     this.datafile = null;
     this.ready = false;
   }
@@ -279,125 +650,194 @@ var AvsBServer = class {
       this.logger.info("Datafile updated", { publishedAt: df.publishedAt });
     }
   }
-  getFlag(flagKey, userContext, defaultValue) {
+  // ---------------------------------------------------------------------------
+  // §5.3 getFlag — required defaultValue, returns Flag<T>
+  // ---------------------------------------------------------------------------
+  getFlag(flagKey, defaultValue, options) {
+    const context = options?.context;
+    const decisionLog = options?.decisionLog;
+    if (!context) {
+      this.logger.warn(
+        `getFlag called without context for flagKey="${flagKey}" \u2014 returning default`
+      );
+      return (0, import_core2.notFoundFlag)(defaultValue, "no context provided");
+    }
     if (!this.ready || !this.datafile) {
       this.logger.debug(`SDK not ready, returning default for ${flagKey}`);
-      return defaultValue;
+      return (0, import_core2.notFoundFlag)(defaultValue, "SDK not ready");
     }
-    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,
+    if (options?.forcedVariationKey) {
+      return this.buildFlagFromVariationKey(
         flagKey,
-        reasons: ["SDK not ready"]
-      };
+        options.forcedVariationKey,
+        defaultValue,
+        "runtimeOverride",
+        context,
+        decisionLog
+      );
     }
-    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
-    };
+    const legacyCtx = this.buildLegacyContext(context, options);
+    const result = this.evaluate(flagKey, legacyCtx, defaultValue);
+    this.emitEvaluation(flagKey, result.value, (0, import_core2.bucketingKey)(context), result.source);
+    return this.toFlag(result, defaultValue, flagKey, context, decisionLog);
   }
-  getAllFlags(userContext) {
+  // ---------------------------------------------------------------------------
+  // §5.11 Typed evaluator variants
+  // ---------------------------------------------------------------------------
+  getBoolFlag(flagKey, defaultValue, options) {
+    return this.getTypedFlag(flagKey, defaultValue, "boolean", options);
+  }
+  getStringFlag(flagKey, defaultValue, options) {
+    return this.getTypedFlag(flagKey, defaultValue, "string", options);
+  }
+  getNumberFlag(flagKey, defaultValue, options) {
+    return this.getTypedFlag(flagKey, defaultValue, "number", options);
+  }
+  getJsonFlag(flagKey, defaultValue, options) {
+    return this.getTypedFlag(flagKey, defaultValue, "json", options);
+  }
+  // ---------------------------------------------------------------------------
+  // §5.7 getAllFlags — returns Record<string, Flag>
+  // ---------------------------------------------------------------------------
+  getAllFlags(context, options) {
     if (!this.ready || !this.datafile) return {};
+    const fireExposures = options?.fireExposures === true;
     const out = {};
-    for (const flag of this.datafile.flags) out[flag.key] = this.getFlag(flag.key, userContext);
+    for (const flagEntry of this.datafile.flags) {
+      const flagOptions = {
+        context,
+        decideOptions: options?.decideOptions
+      };
+      if (!fireExposures) {
+        const suppressCtx = this.buildLegacyContext(context, flagOptions);
+        suppressCtx.suppressExposure = true;
+        const result = this.evaluate(flagEntry.key, suppressCtx, void 0);
+        out[flagEntry.key] = this.toFlagNoLog(result, void 0, flagEntry.key);
+      } else {
+        out[flagEntry.key] = this.getFlag(flagEntry.key, void 0, flagOptions);
+      }
+    }
     return out;
   }
-  track(eventKey, context) {
-    if (!this.ready || !this.tracker) {
-      this.logger.warn(`SDK not ready, dropping track event "${eventKey}"`);
+  // ---------------------------------------------------------------------------
+  // §5.6 Unified track — context required
+  // ---------------------------------------------------------------------------
+  track(eventKey, payload) {
+    const context = payload.context;
+    const userId = (0, import_core2.bucketingKey)(context);
+    if (!this.tracker) {
+      this.pendingEvents.push({ eventKey, payload });
       return;
     }
     this.tracker.queueMetric({
-      visitorId: context.userId,
+      visitorId: userId,
       eventName: eventKey,
-      revenue: context.revenue ?? null,
+      revenue: payload.value ?? null,
       timestamp: Date.now(),
-      pageUrl: ""
+      pageUrl: "",
+      ...payload.properties ? { properties: payload.properties } : {}
     });
   }
-  logExposure(flagKey, userContext) {
+  // ---------------------------------------------------------------------------
+  // §5.13 manualExposure — updated to EvalContext
+  // ---------------------------------------------------------------------------
+  manualExposure(flagKey, context) {
     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 legacyCtx = this.buildLegacyContext(context, { suppressExposure: true });
+    const result = this.evaluate(flagKey, legacyCtx, void 0);
+    if (result.source !== "rule" || !result.ruleId || !result.variationKey) return;
+    if (result.ruleType !== "ab_test" && result.ruleType !== "targeted_delivery") 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;
+    const variation = flag.variations.find((v) => v.key === result.variationKey);
+    if (!variation) return;
+    const userId = (0, import_core2.bucketingKey)(context);
     this.tracker.queue({
-      visitorId: userContext.userId,
+      visitorId: userId,
       experimentId: result.ruleId,
-      variationId: rv.variationId,
+      variationId: variation.id,
       eventName: "flag_exposure",
       revenue: null,
       timestamp: Date.now(),
       pageUrl: "",
-      properties: { flagKey, flagId: flag.id }
+      properties: { flagKey, flagId: flag.id, manuallyFired: true }
     });
   }
-  setOverride(flagKey, variationKey, userId) {
-    if (!this.overrides.has(flagKey)) this.overrides.set(flagKey, /* @__PURE__ */ new Map());
-    this.overrides.get(flagKey).set(userId ?? "*", variationKey);
+  // ---------------------------------------------------------------------------
+  // §5.8 forUser / createUserContext — UserBoundClient factory
+  // ---------------------------------------------------------------------------
+  forUser(context) {
+    return createUserBoundClient(this, context);
+  }
+  createUserContext(context) {
+    return createUserBoundClient(this, context);
+  }
+  // ---------------------------------------------------------------------------
+  // §5.9 Override methods — restructured storage
+  // ---------------------------------------------------------------------------
+  setOverrideForUser(flagKey, contextKey, variationKey, contextKind = "user") {
+    if (!this.overrides.has(flagKey)) {
+      this.overrides.set(flagKey, { perKindKey: /* @__PURE__ */ new Map() });
+    }
+    const entry = this.overrides.get(flagKey);
+    entry.perKindKey.set(`${contextKind}:${contextKey}`, variationKey);
+  }
+  setGlobalOverride(flagKey, variationKey) {
+    if (!this.overrides.has(flagKey)) {
+      this.overrides.set(flagKey, { perKindKey: /* @__PURE__ */ new Map() });
+    }
+    this.overrides.get(flagKey).global = variationKey;
   }
-  clearOverride(flagKey, userId) {
-    const m = this.overrides.get(flagKey);
-    if (!m) return;
-    m.delete(userId ?? "*");
-    if (m.size === 0) this.overrides.delete(flagKey);
+  clearOverrideForUser(flagKey, contextKey, contextKind = "user") {
+    const entry = this.overrides.get(flagKey);
+    if (!entry) return;
+    entry.perKindKey.delete(`${contextKind}:${contextKey}`);
+    if (!entry.global && entry.perKindKey.size === 0) {
+      this.overrides.delete(flagKey);
+    }
+  }
+  clearGlobalOverride(flagKey) {
+    const entry = this.overrides.get(flagKey);
+    if (!entry) return;
+    entry.global = void 0;
+    if (entry.perKindKey.size === 0) {
+      this.overrides.delete(flagKey);
+    }
   }
   clearAllOverrides() {
     this.overrides.clear();
   }
+  // ---------------------------------------------------------------------------
+  // Decision log factory (convenience)
+  // ---------------------------------------------------------------------------
   createDecisionLog() {
     return createDecisionLog();
   }
+  // ---------------------------------------------------------------------------
+  // Event listener API — on() returns unsubscribe; off() kept for compat
+  // ---------------------------------------------------------------------------
   on(event, cb) {
     if (!this.listeners.has(event)) this.listeners.set(event, /* @__PURE__ */ new Set());
     this.listeners.get(event).add(cb);
+    return () => {
+      this.listeners.get(event)?.delete(cb);
+    };
   }
   off(event, cb) {
     this.listeners.get(event)?.delete(cb);
   }
+  // ---------------------------------------------------------------------------
+  // Private — core evaluate
+  // ---------------------------------------------------------------------------
   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",
+        source: "runtimeOverride",
         ruleId: null,
         ruleType: null,
         reasons
@@ -407,31 +847,21 @@ var AvsBServer = class {
       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
-        });
+        if (!uc.suppressExposure) {
+          this.fireExposureForStickyAssignment(flagKey, sticky, uc);
+        }
         return {
-          value: sticky.value,
-          variationKey: sticky.key,
+          value: sticky.vref.value,
+          variationKey: sticky.vref.key,
           source: "sticky",
-          ruleId: null,
-          ruleType: null,
+          ruleId: sticky.assignment.ruleId,
+          ruleType: sticky.assignment.ruleType,
           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 legacyCtx = { attributes: { userId: uc.userId, ...uc.attributes } };
+    const shouldFire = !uc.suppressExposure;
     const onExposure = shouldFire ? (event) => {
       if (uc.privateAttributes?.length && event.properties) {
         const cleaned = { ...event.properties };
@@ -440,41 +870,216 @@ var AvsBServer = class {
       }
       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 r = (0, import_engine.evaluateFlag)(
+      flagKey,
+      defaultValue,
+      legacyCtx,
+      this.datafile,
+      onExposure,
+      reasons
+    );
+    if (this.stickyBucketService && r.variationKey && r.source === "rule" && r.ruleId && r.ruleType === "ab_test") {
       const v = this.findVariation(flagKey, r.variationKey);
-      if (v) this.stickyBucketService.save(uc.userId, flagKey, v.id);
+      if (v) {
+        this.stickyBucketService.save(uc.userId, flagKey, {
+          variationId: v.id,
+          ruleId: r.ruleId,
+          ruleType: r.ruleType,
+          assignedAt: Date.now()
+        });
+      }
     }
-    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,
+      source: (0, import_core2.mapLegacySource)(r.source),
       ruleId: r.ruleId,
       ruleType: r.ruleType,
       reasons
     };
   }
+  // ---------------------------------------------------------------------------
+  // Private — typed evaluation helper
+  // ---------------------------------------------------------------------------
+  getTypedFlag(flagKey, defaultValue, expectedType, options) {
+    const flag = this.getFlag(flagKey, defaultValue, options);
+    if (flag.source === "not_found" || flag.source === "disabled") {
+      return flag;
+    }
+    const datafileFlag = (0, import_core2.findDatafileFlag)(this.datafile, flagKey);
+    const mismatch = (0, import_core2.checkExpectedType)(datafileFlag, expectedType, flag.value);
+    if (mismatch) {
+      this.logger.warn(
+        `Type mismatch on flag "${flagKey}": ${mismatch} \u2014 returning default`
+      );
+      return (0, import_core2.notFoundFlag)(defaultValue, mismatch);
+    }
+    return flag;
+  }
+  // ---------------------------------------------------------------------------
+  // Private — build Flag<T> from an EvalResult
+  // ---------------------------------------------------------------------------
+  toFlag(result, defaultValue, flagKey, context, decisionLog, startMicros) {
+    const evaluatedAt = Date.now();
+    const durationMicros = startMicros !== void 0 ? performance.now() * 1e3 - startMicros : 0;
+    const flag = (0, import_core2.createFlag)({
+      value: result.value ?? defaultValue,
+      variationKey: result.variationKey,
+      source: result.source,
+      ruleId: result.ruleId,
+      ruleType: result.ruleType,
+      reasons: result.reasons,
+      evaluatedAt,
+      durationMicros: Math.round(durationMicros)
+    });
+    if (decisionLog) {
+      const privateAttrs = (0, import_core2.privateAttributesFrom)(context);
+      const summary = (0, import_core2.contextSummary)(context);
+      const redactedValue = privateAttrs.size > 0 && typeof result.value === "string" && privateAttrs.has(result.value) ? "[REDACTED]" : result.value;
+      decisionLog.entries.push({
+        flagKey,
+        value: redactedValue,
+        variationKey: result.variationKey,
+        source: result.source,
+        ruleId: result.ruleId,
+        ruleType: result.ruleType,
+        reasons: [...result.reasons],
+        evaluatedAt,
+        durationMicros: Math.round(durationMicros),
+        contextSummary: summary
+      });
+    }
+    return flag;
+  }
+  /** toFlag variant that never writes a decision log (used by getAllFlags suppressed path). */
+  toFlagNoLog(result, defaultValue, _flagKey) {
+    return (0, import_core2.createFlag)({
+      value: result.value ?? defaultValue,
+      variationKey: result.variationKey,
+      source: result.source,
+      ruleId: result.ruleId,
+      ruleType: result.ruleType,
+      reasons: result.reasons,
+      evaluatedAt: Date.now(),
+      durationMicros: 0
+    });
+  }
+  /** Build a Flag<T> from a forced variation key (per-request override). */
+  buildFlagFromVariationKey(flagKey, variationKey, defaultValue, source, context, decisionLog) {
+    const vref = this.findVariation(flagKey, variationKey);
+    const value = vref ? vref.value : defaultValue;
+    const result = {
+      value,
+      variationKey: vref ? vref.key : null,
+      source,
+      ruleId: null,
+      ruleType: null,
+      reasons: [`forced decision: variationKey="${variationKey}"`]
+    };
+    return this.toFlag(result, defaultValue, flagKey, context, decisionLog);
+  }
+  // ---------------------------------------------------------------------------
+  // Private — build LegacyUserContext from EvalContext
+  // ---------------------------------------------------------------------------
+  buildLegacyContext(context, options) {
+    const legacy = (0, import_core2.toLegacyEvalContext)(context);
+    const userId = legacy.attributes["userId"] ?? "";
+    const privateAttrs = (0, import_core2.privateAttributesFrom)(context);
+    const suppressExposure = options?.suppressExposure === true || options?.decideOptions?.includes("DISABLE_EXPOSURE") === true;
+    const { userId: _uid, ...rest } = legacy.attributes;
+    return {
+      userId,
+      attributes: rest,
+      suppressExposure,
+      privateAttributes: privateAttrs.size > 0 ? [...privateAttrs] : void 0
+    };
+  }
+  // ---------------------------------------------------------------------------
+  // Private — override resolution
+  // ---------------------------------------------------------------------------
+  resolveRuntimeOverride(flagKey, userId) {
+    const entry = this.overrides.get(flagKey);
+    if (!entry) return void 0;
+    const userVk = entry.perKindKey.get(`user:${userId}`);
+    const vk = userVk ?? entry.global;
+    if (!vk) return void 0;
+    return this.findVariation(flagKey, vk) ?? void 0;
+  }
+  // ---------------------------------------------------------------------------
+  // Private — sticky bucket helpers
+  // ---------------------------------------------------------------------------
+  resolveStickyBucket(flagKey, userId) {
+    if (!this.stickyBucketService || !this.datafile) return void 0;
+    const assignment = this.stickyBucketService.lookup(userId, flagKey);
+    if (!assignment) 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 === assignment.variationId);
+    if (!v) return void 0;
+    return { vref: { value: v.value, key: v.key, id: v.id }, assignment };
+  }
+  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 };
+  }
+  fireExposureForStickyAssignment(flagKey, sticky, uc) {
+    if (!this.tracker || !this.datafile) return;
+    const flag = this.datafile.flags.find((f) => f.key === flagKey);
+    if (!flag) return;
+    const rule = flag.rules.find((r) => r.id === sticky.assignment.ruleId);
+    if (!rule || !rule.variations.some((rv) => rv.variationId === sticky.vref.id)) {
+      this.logger.warn(
+        "Sticky assignment references a rule no longer matching the datafile",
+        {
+          flagKey,
+          userId: uc.userId,
+          assignedRuleId: sticky.assignment.ruleId,
+          assignedVariationId: sticky.vref.id
+        }
+      );
+      this.emit("stickyOrphan", {
+        flagKey,
+        userId: uc.userId,
+        assignment: sticky.assignment
+      });
+      return;
+    }
+    this.tracker.queue({
+      visitorId: uc.userId,
+      experimentId: rule.id,
+      variationId: sticky.vref.id,
+      eventName: "flag_exposure",
+      revenue: null,
+      timestamp: Date.now(),
+      pageUrl: "",
+      properties: { flagKey, flagId: flag.id }
+    });
+  }
+  // ---------------------------------------------------------------------------
+  // Private — event emission
+  // ---------------------------------------------------------------------------
   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) });
       }
     }
   }
+  emitEvaluation(flagKey, value, userId, source) {
+    this.emit("evaluation", { flagKey, value, userId, source });
+  }
+  // ---------------------------------------------------------------------------
+  // Private — tracker + polling + streaming
+  // ---------------------------------------------------------------------------
   initTracker() {
     if (!this.datafile || this.tracker) return;
     this.tracker = createServerTracker({
@@ -486,17 +1091,37 @@ var AvsBServer = class {
       retryAttempts: this.eventOptions.retryAttempts,
       logger: this.logger
     });
+    if (this.pendingEvents.length > 0) {
+      const queued = this.pendingEvents;
+      this.pendingEvents = [];
+      for (const item of queued) {
+        this.track(item.eventKey, item.payload);
+      }
+    }
+  }
+  startStreamingIfEnabled() {
+    if (!this.streamingEnabled || this.streamingClient || this.destroyed) return;
+    this.streamingClient = createStreamingClient({
+      endpoint: this.streamingEndpoint,
+      sdkKey: this.sdkKey,
+      onDatafileUpdated: () => {
+        void this.refreshDatafile();
+      },
+      logger: this.logger
+    });
+    this.streamingClient.connect();
   }
   async fetchDatafile() {
     const url = `${this.cdnHost}/${this.sdkKey}/datafile.json`;
     try {
-      const res = await fetch(url, { signal: AbortSignal.timeout(1e4) });
+      const res = await fetch(url, { signal: this.abortController.signal });
       if (!res.ok) {
         this.logger.warn("Datafile fetch failed", { status: res.status, url });
         return null;
       }
       return await res.json();
     } catch (e) {
+      if (this.abortController.signal.aborted) return null;
       this.logger.warn("Datafile fetch error", { error: String(e), url });
       return null;
     }
@@ -524,96 +1149,58 @@ var AvsBServer = class {
     fetch(this.datafile.heartbeatEndpoint, {
       method: "POST",
       headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({ sdkKey: this.sdkKey, sdkType: "@avsbhq/node", sdkVersion: SDK_VERSION })
+      body: JSON.stringify({
+        sdkKey: this.sdkKey,
+        sdkType: "@avsbhq/node",
+        sdkVersion: SDK_VERSION
+      }),
+      signal: this.abortController.signal
     }).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() {
+function createNoopUserBoundClient() {
+  const noopFlag = (defaultValue) => ({
+    value: defaultValue,
+    variationKey: null,
+    source: "not_found",
+    ruleId: null,
+    ruleType: null,
+    reasons: ["no userId available"],
+    evaluatedAt: Date.now(),
+    durationMicros: 0,
+    isEnabled: () => false,
+    exists: () => false
+  });
   return {
     getFlag(_flagKey, defaultValue) {
-      return defaultValue;
+      return noopFlag(defaultValue);
     },
-    getFlagDetails(flagKey) {
-      return {
-        value: void 0,
-        variationKey: null,
-        source: "not_found",
-        ruleId: null,
-        ruleType: null,
-        flagKey,
-        reasons: ["no userId available"]
-      };
+    getBoolFlag(_flagKey, defaultValue) {
+      return noopFlag(defaultValue);
+    },
+    getStringFlag(_flagKey, defaultValue) {
+      return noopFlag(defaultValue);
+    },
+    getNumberFlag(_flagKey, defaultValue) {
+      return noopFlag(defaultValue);
+    },
+    getJsonFlag(_flagKey, defaultValue) {
+      return noopFlag(defaultValue);
     },
     getAllFlags() {
       return {};
     },
     track() {
+    },
+    setForcedDecision() {
+    },
+    clearForcedDecision() {
+    },
+    getDecisionLog() {
+      return { entries: [] };
     }
   };
 }
@@ -622,25 +1209,12 @@ function expressMiddleware(client, config) {
     const userId = config.userIdFrom(req);
     if (!userId) {
       ;
-      req.avsb = createNoopRequestAvsB();
+      req.avsb = createNoopUserBoundClient();
       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 });
-      }
-    };
+    const context = { kind: "user", key: userId, ...attributes };
+    req.avsb = client.forUser(context);
     next();
   };
 }
@@ -653,30 +1227,20 @@ function fastifyPlugin(instance, opts, done) {
     const userId = opts.userIdFrom(req);
     if (!userId) {
       ;
-      req.avsb = createNoopRequestAvsB();
+      req.avsb = createNoopUserBoundClient();
       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 });
-      }
-    };
+    const context = { kind: "user", key: userId, ...attributes };
+    req.avsb = opts.client.forUser(context);
     hookDone();
   });
   done();
 }
 
+// src/logger.ts
+var import_core3 = require("@avsbhq/core");
+
 // src/stickyBucket.ts
 var InMemoryStickyBucketService = class {
   cache = /* @__PURE__ */ new Map();
@@ -686,10 +1250,15 @@ var InMemoryStickyBucketService = class {
   lookup(userId, flagKey) {
     return this.cache.get(this.key(userId, flagKey)) ?? null;
   }
-  save(userId, flagKey, variationId) {
-    this.cache.set(this.key(userId, flagKey), variationId);
+  save(userId, flagKey, assignment) {
+    this.cache.set(this.key(userId, flagKey), assignment);
   }
 };
+function isStickyAssignment(value) {
+  if (!value || typeof value !== "object") return false;
+  const v = value;
+  return typeof v.variationId === "string" && typeof v.ruleId === "string" && typeof v.ruleType === "string" && typeof v.assignedAt === "number";
+}
 var RedisStickyBucketService = class {
   redis;
   prefix;
@@ -702,7 +1271,7 @@ var RedisStickyBucketService = class {
     this.prefix = options.prefix ?? "avsb:sticky:";
     this.ttl = options.ttl ?? 2592e3;
     this.maxCacheSize = options.cacheSize ?? 1e4;
-    this.logger = options.logger ?? noopLogger;
+    this.logger = options.logger ?? import_core3.noopLogger;
   }
   redisKey(userId, flagKey) {
     return `${this.prefix}${userId}:${flagKey}`;
@@ -717,12 +1286,13 @@ var RedisStickyBucketService = class {
     this.backgroundFetch(userId, flagKey);
     return null;
   }
-  save(userId, flagKey, variationId) {
+  save(userId, flagKey, assignment) {
     const ck = this.cacheKey(userId, flagKey);
-    this.cache.set(ck, variationId);
+    this.cache.set(ck, assignment);
     this.evictIfNeeded();
     const rk = this.redisKey(userId, flagKey);
-    this.redis.set(rk, variationId, { EX: this.ttl }).catch((e) => {
+    const serialized = JSON.stringify(assignment);
+    this.redis.set(rk, serialized, { EX: this.ttl }).catch((e) => {
       this.logger.error("Redis sticky bucket save failed", {
         key: rk,
         error: String(e)
@@ -733,10 +1303,20 @@ var RedisStickyBucketService = class {
     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();
+      if (value === null) return;
+      let parsed;
+      try {
+        parsed = JSON.parse(value);
+      } catch {
+        this.logger.warn("Redis sticky bucket value is not valid JSON", { key: rk });
+        return;
+      }
+      if (!isStickyAssignment(parsed)) {
+        this.logger.warn("Redis sticky bucket value missing required fields", { key: rk });
+        return;
       }
+      this.cache.set(ck, parsed);
+      this.evictIfNeeded();
     }).catch((e) => {
       this.logger.error("Redis sticky bucket fetch failed", {
         key: rk,
@@ -753,111 +1333,19 @@ var RedisStickyBucketService = class {
   }
 };
 
-// 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 };
-}
+// src/index.ts
+var import_core4 = require("@avsbhq/core");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  AvsBServer,
+  AvsbServer,
+  DecideOption,
   InMemoryStickyBucketService,
   RedisStickyBucketService,
   SDK_VERSION,
+  consoleLogger,
+  consoleTransport,
   createDecisionLog,
+  createLogger,
   createStreamingClient,
   expressMiddleware,
   fastifyPlugin,