@emit-vision/sdk-js 0.3.0 → 0.4.1

package/dist/index.d.ts

@@ -69,26 +69,23 @@ type EmitVisionOptions = {
     /** Disable the SDK after this many consecutive flush failures: the queue is dropped, future captures become no-ops, and a single warning is logged. Default: 20. Set to 0 to disable the cap and retry forever. */
     maxConsecutiveFlushFailures?: number;
 };
-
 type RequiredEmitVisionOptions = Required<Pick<EmitVisionOptions, "apiKey" | "endpoint" | "flushIntervalMs" | "batchSize" | "fetchImpl" | "flushOnCapture" | "flagEvalTtlMs" | "retryBackoffInitialMs" | "retryBackoffMaxMs" | "maxConsecutiveFlushFailures">> & Pick<EmitVisionOptions, "environment" | "release" | "sessionId" | "label" | "deployment" | "featureFlags" | "debug"> & {
     autoCapture: Required<AutoCaptureOptions> & {
         flagExposures: boolean;
         pageViews: boolean;
     };
 };
+
 declare class EmitVisionClient {
     private readonly options;
-    private queue;
     private user;
     private context;
     private deployment;
     private featureFlags;
     private tags;
-    private timer;
-    private flushScheduled;
-    private readonly fetchImpl;
     private readonly flagEval;
-    private readonly retry;
+    private readonly autoCapture;
+    private readonly flusher;
     constructor(options: RequiredEmitVisionOptions);
     captureEvent(name: string, properties?: Record<string, unknown>, options?: CaptureOptions): void;
     captureError(error: unknown, options?: CaptureOptions): void;
@@ -100,31 +97,27 @@ declare class EmitVisionClient {
     getFlag<T extends string | number | boolean | null>(flagKey: string, fallback: T, opts: FlagEvaluationOptions): Promise<T>;
     refreshFlags(opts: FlagEvaluationOptions): Promise<FeatureFlagsContext>;
     capturePageView(path?: string): void;
+    captureFeedback(feedback: {
+        message: string;
+        rating?: number;
+        url?: string;
+    }, options?: CaptureOptions): void;
     captureExposure(flagKey: string, variantKey: string, variantValue?: string | number | boolean | null, reason?: string, environment?: string): void;
     setTags(tags: Record<string, string>): void;
     flush(): Promise<void>;
-    private flushChunk;
-    private handleFlushFailure;
-    private stopBackgroundWork;
     close(): void;
-    private enqueueMetaEvent;
-    private enqueue;
-    private scheduleFlush;
     private withDefaults;
-    private mergeDeployment;
-    private mergeFeatureFlags;
-    private readonly handleWindowError;
-    private readonly handlePopState;
-    private patchHistoryMethod;
-    private restoreHistoryMethod;
-    private readonly handleUnhandledRejection;
-    private debug;
 }
 
 declare function init(options: EmitVisionOptions): EmitVisionClient;
 declare function captureEvent(name: string, properties?: Record<string, unknown>, options?: CaptureOptions): void;
 declare function captureError(error: unknown, options?: CaptureOptions): void;
 declare function capturePageView(path?: string): void;
+declare function captureFeedback(feedback: {
+    message: string;
+    rating?: number;
+    url?: string;
+}, options?: CaptureOptions): void;
 declare function identify(user: EmitVisionUser): void;
 declare function identify(userId: string, traits?: EmitVisionTraits): void;
 declare function setContext(context: Record<string, unknown>): void;
@@ -137,4 +130,4 @@ declare function getFlag<T extends string | number | boolean | null>(flagKey: st
 declare function refreshFlags(options: FlagEvaluationOptions): Promise<FeatureFlagsContext>;
 declare function captureExposure(flagKey: string, variantKey: string, variantValue?: string | number | boolean | null, reason?: string, environment?: string): void;
 
-export { type AutoCaptureOptions, type CaptureOptions, type DeploymentContext, type EmitVisionOptions, type EmitVisionTraits, type EmitVisionUser, type FeatureFlagsContext, type FlagEvaluationOptions, captureError, captureEvent, captureExposure, capturePageView, evaluateFlags, flush, getFlag, identify, init, refreshFlags, setContext, setDeploymentContext, setFeatureFlags, setTags };
+export { type AutoCaptureOptions, type CaptureOptions, type DeploymentContext, type EmitVisionOptions, type EmitVisionTraits, type EmitVisionUser, type FeatureFlagsContext, type FlagEvaluationOptions, captureError, captureEvent, captureExposure, captureFeedback, capturePageView, evaluateFlags, flush, getFlag, identify, init, refreshFlags, setContext, setDeploymentContext, setFeatureFlags, setTags };

package/dist/index.js

@@ -1,61 +1,3 @@
-// src/retry.ts
-var FlushRetryController = class {
-  constructor(opts) {
-    this.opts = opts;
-  }
-  opts;
-  consecutiveFailures = 0;
-  backoffUntil = 0;
-  disabled = false;
-  isDisabled() {
-    return this.disabled;
-  }
-  isBackingOff(now = Date.now()) {
-    return !this.disabled && now < this.backoffUntil;
-  }
-  msUntilReady(now = Date.now()) {
-    if (this.disabled) return Infinity;
-    return Math.max(0, this.backoffUntil - now);
-  }
-  reset() {
-    this.consecutiveFailures = 0;
-    this.backoffUntil = 0;
-  }
-  recordFailure(now = Date.now()) {
-    this.consecutiveFailures += 1;
-    if (this.opts.failureCap > 0 && this.consecutiveFailures >= this.opts.failureCap) {
-      const wasDisabled = this.disabled;
-      this.disabled = true;
-      this.backoffUntil = 0;
-      return {
-        backoffMs: 0,
-        consecutiveFailures: this.consecutiveFailures,
-        justDisabled: !wasDisabled
-      };
-    }
-    if (this.opts.initialMs <= 0) {
-      this.backoffUntil = 0;
-      return {
-        backoffMs: 0,
-        consecutiveFailures: this.consecutiveFailures,
-        justDisabled: false
-      };
-    }
-    const exp = Math.min(
-      this.opts.initialMs * Math.pow(2, this.consecutiveFailures - 1),
-      this.opts.maxMs
-    );
-    const jitter = exp * 0.2 * (Math.random() * 2 - 1);
-    const backoffMs = Math.max(0, Math.floor(exp + jitter));
-    this.backoffUntil = now + backoffMs;
-    return {
-      backoffMs,
-      consecutiveFailures: this.consecutiveFailures,
-      justDisabled: false
-    };
-  }
-};
-
 // src/flag-eval.ts
 var FlagEvaluator = class {
   constructor(cfg, onFlagsLoaded, captureExposure2, debug) {
@@ -215,9 +157,9 @@ function resolveAutoCapture(options) {
   };
 }
 
-// src/client.ts
+// src/client-helpers.ts
 var SDK_NAME = "emit-vision-js";
-var SDK_VERSION = "0.3.0";
+var SDK_VERSION = "0.4.0";
 var MAX_EVENT_BYTES = 64 * 1024;
 var MAX_BATCH_BYTES = 1 * 1024 * 1024;
 function byteLength(s) {
@@ -248,7 +190,11 @@ function trimEventIfOversized(payload) {
   };
   if (payload.type === "error") {
     return {
-      payload: { ...payload, ...base, error: { ...payload.error, stack: void 0 } },
+      payload: {
+        ...payload,
+        ...base,
+        error: { ...payload.error, stack: void 0 }
+      },
       trimmedFields,
       originalBytes
     };
@@ -270,55 +216,423 @@ function splitBatch(batch) {
   const mid = Math.floor(batch.length / 2);
   return [...splitBatch(batch.slice(0, mid)), ...splitBatch(batch.slice(mid))];
 }
-var EmitVisionClient = class {
-  constructor(options) {
+
+// src/client-internals.ts
+function debugLog(message, opts, payload) {
+  if (!opts.debug || typeof console.debug !== "function") return;
+  const prefix = opts.label ? `[emit-vision:${opts.label}]` : "[emit-vision]";
+  if (payload === void 0) {
+    console.debug(prefix, message);
+    return;
+  }
+  console.debug(prefix, message, payload);
+}
+function buildMetaEvent(originalName, originalBytes, trimmedFields, opts) {
+  return {
+    type: "event",
+    name: "sdk.event_truncated",
+    properties: {
+      originalName,
+      originalBytes,
+      trimmedFields,
+      sdkName: SDK_NAME
+    },
+    environment: opts.environment,
+    release: opts.release
+  };
+}
+function buildWithDefaults(clientUser, clientContext, clientDeployment, clientFeatureFlags, clientTags, sdkOpts, captureOpts) {
+  const {
+    context,
+    deployment,
+    featureFlags,
+    tags,
+    user,
+    environment,
+    release,
+    sessionId,
+    ...rest
+  } = captureOpts;
+  return {
+    ...rest,
+    environment: environment ?? sdkOpts.environment,
+    release: release ?? sdkOpts.release,
+    sessionId: sessionId ?? sdkOpts.sessionId,
+    user: user ?? clientUser,
+    context: Object.keys(clientContext).length ? { ...clientContext, ...context } : context,
+    deployment: mergeDeploymentFn(clientDeployment, deployment),
+    featureFlags: mergeFeatureFlagsFn(clientFeatureFlags, featureFlags),
+    tags: Object.keys(clientTags).length ? { ...clientTags, ...tags } : tags
+  };
+}
+function mergeDeploymentFn(clientDeployment, overrideDeployment) {
+  const merged = { ...clientDeployment ?? {}, ...overrideDeployment ?? {} };
+  return Object.keys(merged).length > 0 ? merged : void 0;
+}
+function mergeFeatureFlagsFn(clientFlags, overrideFlags) {
+  const merged = { ...clientFlags, ...overrideFlags ?? {} };
+  return Object.keys(merged).length > 0 ? merged : void 0;
+}
+function buildFlushDisabledMessage(label, consecutiveFailures, dropped) {
+  return `[emit-vision${label ? `:${label}` : ""}] disabled after ${consecutiveFailures} consecutive flush failures; dropping ${dropped} queued events. Re-init the SDK to resume.`;
+}
+async function executeHttpSend(chunk, endpoint, apiKey, fetchImpl) {
+  const response = await fetchImpl(`${endpoint}/v1/batch`, {
+    method: "POST",
+    headers: { "content-type": "application/json", "x-emit-api-key": apiKey },
+    body: buildBatchBody(chunk),
+    keepalive: true
+  });
+  if (!response.ok) {
+    throw new Error(`emit-vision flush failed with ${response.status}`);
+  }
+}
+
+// src/retry.ts
+var FlushRetryController = class {
+  constructor(opts) {
+    this.opts = opts;
+  }
+  opts;
+  consecutiveFailures = 0;
+  backoffUntil = 0;
+  disabled = false;
+  isDisabled() {
+    return this.disabled;
+  }
+  isBackingOff(now = Date.now()) {
+    return !this.disabled && now < this.backoffUntil;
+  }
+  msUntilReady(now = Date.now()) {
+    if (this.disabled) return Infinity;
+    return Math.max(0, this.backoffUntil - now);
+  }
+  reset() {
+    this.consecutiveFailures = 0;
+    this.backoffUntil = 0;
+  }
+  recordFailure(now = Date.now()) {
+    this.consecutiveFailures += 1;
+    if (this.opts.failureCap > 0 && this.consecutiveFailures >= this.opts.failureCap) {
+      const wasDisabled = this.disabled;
+      this.disabled = true;
+      this.backoffUntil = 0;
+      return {
+        backoffMs: 0,
+        consecutiveFailures: this.consecutiveFailures,
+        justDisabled: !wasDisabled
+      };
+    }
+    if (this.opts.initialMs <= 0) {
+      this.backoffUntil = 0;
+      return {
+        backoffMs: 0,
+        consecutiveFailures: this.consecutiveFailures,
+        justDisabled: false
+      };
+    }
+    const exp = Math.min(
+      this.opts.initialMs * Math.pow(2, this.consecutiveFailures - 1),
+      this.opts.maxMs
+    );
+    const jitter = exp * 0.2 * (Math.random() * 2 - 1);
+    const backoffMs = Math.max(0, Math.floor(exp + jitter));
+    this.backoffUntil = now + backoffMs;
+    return {
+      backoffMs,
+      consecutiveFailures: this.consecutiveFailures,
+      justDisabled: false
+    };
+  }
+};
+
+// src/client-flush.ts
+var FlushManager = class {
+  constructor(options, fetchImpl) {
     this.options = options;
-    this.fetchImpl = options.fetchImpl;
-    this.deployment = options.deployment ? { ...options.deployment } : void 0;
-    this.featureFlags = options.featureFlags ? { ...options.featureFlags } : {};
+    this.fetchImpl = fetchImpl;
     this.retry = new FlushRetryController({
       initialMs: options.retryBackoffInitialMs,
       maxMs: options.retryBackoffMaxMs,
       failureCap: options.maxConsecutiveFlushFailures
     });
-    this.flagEval = new FlagEvaluator(
-      {
-        endpoint: options.endpoint,
-        apiKey: options.apiKey,
-        ttlMs: options.flagEvalTtlMs,
-        flagExposures: options.autoCapture.flagExposures,
-        fetchImpl: options.fetchImpl
-      },
-      (flags) => {
-        this.featureFlags = { ...this.featureFlags, ...flags };
-      },
-      (flagKey, variantKey, variantValue, reason, env) => this.captureExposure(flagKey, variantKey, variantValue, reason, env),
-      (msg, data) => this.debug(msg, data)
-    );
     this.timer = setInterval(() => {
-      if (this.queue.length === 0 || this.retry.isBackingOff()) {
-        return;
-      }
+      if (this.queue.length === 0 || this.retry.isBackingOff()) return;
       this.flush().catch(
-        (err) => this.debug("background flush error", { error: err })
+        (err) => debugLog("background flush error", this.options, { error: err })
       );
     }, options.flushIntervalMs);
-    if (options.autoCapture.errors && typeof window !== "undefined") {
+  }
+  options;
+  fetchImpl;
+  queue = [];
+  timer;
+  flushScheduled = false;
+  retry;
+  enqueue(payload) {
+    if (this.retry.isDisabled()) return;
+    const {
+      payload: trimmed,
+      trimmedFields,
+      originalBytes
+    } = trimEventIfOversized(payload);
+    this.queue.push(trimmed);
+    if (trimmedFields !== null) {
+      const meta = buildMetaEvent(
+        payload.name,
+        originalBytes,
+        trimmedFields,
+        this.options
+      );
+      this.queue.push(meta);
+    }
+    debugLog("queued payload", this.options, {
+      type: payload.type,
+      name: payload.name,
+      queueSize: this.queue.length,
+      flushOnCapture: this.options.flushOnCapture,
+      batchSize: this.options.batchSize
+    });
+    if (this.options.flushOnCapture) {
+      if (!this.retry.isBackingOff()) {
+        this.flush().catch(
+          (err) => debugLog("capture flush error", this.options, { error: err })
+        );
+      }
+      return;
+    }
+    if (this.queue.length >= this.options.batchSize && !this.retry.isBackingOff()) {
+      this.flush().catch(
+        (err) => debugLog("batch flush error", this.options, { error: err })
+      );
+    }
+  }
+  async flush() {
+    if (this.retry.isDisabled()) return;
+    const batch = this.queue.splice(0, this.options.batchSize);
+    if (batch.length === 0) return;
+    debugLog("flushing batch", this.options, { count: batch.length });
+    const chunks = splitBatch(batch);
+    for (let i = 0; i < chunks.length; i++) {
+      const tailCount = chunks.slice(i + 1).reduce((s, c) => s + c.length, 0);
+      try {
+        await this.flushChunk(chunks[i], tailCount);
+      } catch (err) {
+        if (!this.retry.isDisabled()) {
+          const tail = chunks.slice(i + 1).flat();
+          if (tail.length > 0) {
+            this.queue.splice(chunks[i].length, 0, ...tail);
+          }
+        }
+        throw err;
+      }
+    }
+    if (this.options.flushOnCapture && this.queue.length > 0) {
+      this.scheduleFlush();
+    }
+  }
+  close() {
+    if (this.timer) {
+      clearInterval(this.timer);
+      this.timer = void 0;
+    }
+  }
+  async flushChunk(chunk, tailCount) {
+    try {
+      await executeHttpSend(
+        chunk,
+        this.options.endpoint,
+        this.options.apiKey,
+        this.fetchImpl
+      );
+    } catch (err) {
+      const m = err instanceof Error ? /flush failed with (\d+)/.exec(err.message) : null;
+      this.handleFlushFailure(
+        chunk,
+        tailCount,
+        m ? { reason: "status", status: Number(m[1]) } : { reason: "network", error: err }
+      );
+      throw err;
+    }
+    this.retry.reset();
+    debugLog("flush complete", this.options, { count: chunk.length });
+  }
+  handleFlushFailure(batch, tailCount, detail) {
+    const result = this.retry.recordFailure();
+    if (result.justDisabled) {
+      const dropped = this.queue.length + batch.length + tailCount;
+      this.queue = [];
+      this.close();
+      const msg = buildFlushDisabledMessage(
+        this.options.label,
+        result.consecutiveFailures,
+        dropped
+      );
+      if (typeof console.warn === "function") console.warn(msg);
+      debugLog("disabled", this.options, {
+        consecutiveFailures: result.consecutiveFailures,
+        dropped
+      });
+      return;
+    }
+    this.queue.unshift(...batch);
+    const base = {
+      restoredCount: batch.length,
+      consecutiveFailures: result.consecutiveFailures,
+      backoffMs: result.backoffMs
+    };
+    if (detail.reason === "network") {
+      debugLog("flush network error", this.options, {
+        error: detail.error,
+        ...base
+      });
+    } else {
+      debugLog("flush failed", this.options, {
+        status: detail.status,
+        ...base
+      });
+    }
+  }
+  scheduleFlush() {
+    if (this.flushScheduled) return;
+    this.flushScheduled = true;
+    queueMicrotask(() => {
+      this.flushScheduled = false;
+      if (this.queue.length === 0 || this.retry.isBackingOff()) return;
+      this.flush().catch(
+        (err) => debugLog("scheduled flush error", this.options, { error: err })
+      );
+    });
+  }
+};
+
+// src/client-autocapture.ts
+var BrowserAutoCapture = class {
+  constructor(onCapture, withDefaults, onPageView, config) {
+    this.onCapture = onCapture;
+    this.withDefaults = withDefaults;
+    this.onPageView = onPageView;
+    this.config = config;
+  }
+  onCapture;
+  withDefaults;
+  onPageView;
+  config;
+  attach() {
+    if (typeof window === "undefined") return;
+    if (this.config.errors) {
       window.addEventListener("error", this.handleWindowError);
     }
-    if (options.autoCapture.unhandledRejections && typeof window !== "undefined") {
+    if (this.config.unhandledRejections) {
       window.addEventListener(
         "unhandledrejection",
         this.handleUnhandledRejection
       );
     }
-    if (options.autoCapture.pageViews && typeof window !== "undefined") {
-      this.capturePageView();
+    if (this.config.pageViews) {
+      this.onPageView();
       window.addEventListener("popstate", this.handlePopState);
       this.patchHistoryMethod("pushState");
       this.patchHistoryMethod("replaceState");
     }
-    this.debug("initialized", {
+  }
+  detach() {
+    if (typeof window === "undefined") return;
+    if (this.config.errors) {
+      window.removeEventListener("error", this.handleWindowError);
+    }
+    if (this.config.unhandledRejections) {
+      window.removeEventListener(
+        "unhandledrejection",
+        this.handleUnhandledRejection
+      );
+    }
+    if (this.config.pageViews) {
+      window.removeEventListener("popstate", this.handlePopState);
+      this.restoreHistoryMethod("pushState");
+      this.restoreHistoryMethod("replaceState");
+    }
+  }
+  handleWindowError = (event) => {
+    const serialized = serializeError(event.error ?? event.message);
+    this.onCapture({
+      type: "error",
+      name: "error",
+      error: { ...serialized, handled: false },
+      ...this.withDefaults({
+        context: {
+          source: "window.error",
+          url: window.location.href,
+          page: window.location.pathname
+        }
+      })
+    });
+  };
+  handlePopState = () => {
+    this.onPageView();
+  };
+  handleUnhandledRejection = (event) => {
+    const serialized = serializeError(event.reason);
+    this.onCapture({
+      type: "error",
+      name: "error",
+      error: { ...serialized, handled: false },
+      ...this.withDefaults({
+        context: {
+          source: "window.unhandledrejection",
+          url: window.location.href,
+          page: window.location.pathname
+        }
+      })
+    });
+  };
+  patchHistoryMethod(method) {
+    const original = history[method].bind(history);
+    const historyWithCustom = history;
+    historyWithCustom[`__ev_orig_${method}`] = original;
+    historyWithCustom[method] = (...args) => {
+      original(...args);
+      this.onPageView();
+    };
+  }
+  restoreHistoryMethod(method) {
+    const historyWithCustom = history;
+    const original = historyWithCustom[`__ev_orig_${method}`];
+    if (original) {
+      historyWithCustom[method] = original;
+    }
+  }
+};
+
+// src/client.ts
+var EmitVisionClient = class {
+  constructor(options) {
+    this.options = options;
+    this.deployment = options.deployment ? { ...options.deployment } : void 0;
+    this.featureFlags = options.featureFlags ? { ...options.featureFlags } : {};
+    this.flusher = new FlushManager(options, options.fetchImpl);
+    this.flagEval = new FlagEvaluator(
+      {
+        endpoint: options.endpoint,
+        apiKey: options.apiKey,
+        ttlMs: options.flagEvalTtlMs,
+        flagExposures: options.autoCapture.flagExposures,
+        fetchImpl: options.fetchImpl
+      },
+      (flags) => {
+        this.featureFlags = { ...this.featureFlags, ...flags };
+      },
+      (flagKey, variantKey, variantValue, reason, env) => this.captureExposure(flagKey, variantKey, variantValue, reason, env),
+      (msg, data) => debugLog(msg, this.options, data)
+    );
+    this.autoCapture = new BrowserAutoCapture(
+      (payload) => this.flusher.enqueue(payload),
+      (opts) => this.withDefaults(opts),
+      () => this.capturePageView(),
+      options.autoCapture
+    );
+    this.autoCapture.attach();
+    debugLog("initialized", this.options, {
       endpoint: options.endpoint,
       environment: options.environment,
       release: options.release,
@@ -329,20 +643,17 @@ var EmitVisionClient = class {
     });
   }
   options;
-  queue = [];
   user;
   context = {};
   deployment;
   featureFlags = {};
   tags = {};
-  timer;
-  flushScheduled = false;
-  fetchImpl;
   flagEval;
-  retry;
+  autoCapture;
+  flusher;
   captureEvent(name, properties, options = {}) {
-    this.debug("queue event", { name, properties, options });
-    this.enqueue({
+    debugLog("queue event", this.options, { name, properties, options });
+    this.flusher.enqueue({
       type: "event",
       name,
       properties,
@@ -351,12 +662,11 @@ var EmitVisionClient = class {
   }
   captureError(error, options = {}) {
     const serialized = serializeError(error);
-    this.debug("queue error", {
+    debugLog("queue error", this.options, {
       message: serialized.message,
-      handled: serialized.handled,
       options
     });
-    this.enqueue({
+    this.flusher.enqueue({
       type: "error",
       name: "error",
       error: serialized,
@@ -365,19 +675,19 @@ var EmitVisionClient = class {
   }
   identify(userIdOrUser, traits = {}) {
     this.user = typeof userIdOrUser === "string" ? { id: userIdOrUser, ...traits } : { ...userIdOrUser };
-    this.debug("identified user", this.user);
+    debugLog("identified user", this.options, this.user);
   }
   setContext(context) {
     this.context = { ...this.context, ...context };
-    this.debug("updated context", this.context);
+    debugLog("updated context", this.options, this.context);
   }
   setDeploymentContext(context) {
     this.deployment = Object.keys(context).length > 0 ? { ...context } : void 0;
-    this.debug("updated deployment context", this.deployment);
+    debugLog("updated deployment context", this.options, this.deployment);
   }
   setFeatureFlags(featureFlags) {
     this.featureFlags = { ...featureFlags };
-    this.debug("updated feature flags", this.featureFlags);
+    debugLog("updated feature flags", this.options, this.featureFlags);
   }
   evaluateFlags(opts) {
     return this.flagEval.evaluateFlags({
@@ -402,6 +712,14 @@ var EmitVisionClient = class {
     if (!page) return;
     this.captureEvent("$page_view", { page });
   }
+  captureFeedback(feedback, options = {}) {
+    const url = feedback.url ?? (typeof window !== "undefined" ? window.location.href : void 0);
+    this.captureEvent(
+      "$feedback",
+      { message: feedback.message, ...feedback.rating !== void 0 ? { rating: feedback.rating } : {}, ...url ? { url } : {} },
+      options
+    );
+  }
   captureExposure(flagKey, variantKey, variantValue, reason, environment) {
     this.captureEvent("$flag_exposure", {
       flagKey,
@@ -413,270 +731,26 @@ var EmitVisionClient = class {
   }
   setTags(tags) {
     this.tags = { ...this.tags, ...tags };
-    this.debug("updated tags", this.tags);
+    debugLog("updated tags", this.options, this.tags);
   }
-  async flush() {
-    if (this.retry.isDisabled()) {
-      return;
-    }
-    const batch = this.queue.splice(0, this.options.batchSize);
-    if (batch.length === 0) {
-      return;
-    }
-    this.debug("flushing batch", { count: batch.length });
-    const chunks = splitBatch(batch);
-    for (let i = 0; i < chunks.length; i++) {
-      try {
-        await this.flushChunk(chunks[i]);
-      } catch (err) {
-        if (!this.retry.isDisabled()) {
-          const tail = chunks.slice(i + 1).flat();
-          if (tail.length > 0) {
-            this.queue.splice(chunks[i].length, 0, ...tail);
-          }
-        }
-        throw err;
-      }
-    }
-    if (this.options.flushOnCapture && this.queue.length > 0) {
-      this.scheduleFlush();
-    }
-  }
-  async flushChunk(chunk) {
-    let response;
-    try {
-      response = await this.fetchImpl(`${this.options.endpoint}/v1/batch`, {
-        method: "POST",
-        headers: {
-          "content-type": "application/json",
-          "x-emit-api-key": this.options.apiKey
-        },
-        body: buildBatchBody(chunk),
-        keepalive: true
-      });
-    } catch (err) {
-      this.handleFlushFailure(chunk, { reason: "network", error: err });
-      throw err;
-    }
-    if (!response.ok) {
-      const error = new Error(
-        `emit-vision flush failed with ${response.status}`
-      );
-      this.handleFlushFailure(chunk, {
-        reason: "status",
-        status: response.status
-      });
-      throw error;
-    }
-    this.retry.reset();
-    this.debug("flush complete", { count: chunk.length });
-  }
-  handleFlushFailure(batch, detail) {
-    const result = this.retry.recordFailure();
-    if (result.justDisabled) {
-      const droppedQueued = this.queue.length;
-      const droppedBatch = batch.length;
-      this.queue = [];
-      this.stopBackgroundWork();
-      const message = `[emit-vision${this.options.label ? `:${this.options.label}` : ""}] disabled after ${result.consecutiveFailures} consecutive flush failures; dropping ${droppedQueued + droppedBatch} queued events. Re-init the SDK to resume.`;
-      if (typeof console.warn === "function") {
-        console.warn(message);
-      }
-      this.debug("disabled", {
-        consecutiveFailures: result.consecutiveFailures,
-        dropped: droppedQueued + droppedBatch
-      });
-      return;
-    }
-    this.queue.unshift(...batch);
-    if (detail.reason === "network") {
-      this.debug("flush network error", {
-        error: detail.error,
-        restoredCount: batch.length,
-        consecutiveFailures: result.consecutiveFailures,
-        backoffMs: result.backoffMs
-      });
-    } else {
-      this.debug("flush failed", {
-        status: detail.status,
-        restoredCount: batch.length,
-        consecutiveFailures: result.consecutiveFailures,
-        backoffMs: result.backoffMs
-      });
-    }
-  }
-  stopBackgroundWork() {
-    if (this.timer) {
-      clearInterval(this.timer);
-      this.timer = void 0;
-    }
+  flush() {
+    return this.flusher.flush();
   }
   close() {
-    this.stopBackgroundWork();
-    if (typeof window !== "undefined" && this.options.autoCapture.errors) {
-      window.removeEventListener("error", this.handleWindowError);
-    }
-    if (typeof window !== "undefined" && this.options.autoCapture.unhandledRejections) {
-      window.removeEventListener(
-        "unhandledrejection",
-        this.handleUnhandledRejection
-      );
-    }
-    if (typeof window !== "undefined" && this.options.autoCapture.pageViews) {
-      window.removeEventListener("popstate", this.handlePopState);
-      this.restoreHistoryMethod("pushState");
-      this.restoreHistoryMethod("replaceState");
-    }
-    this.debug("closed client");
-  }
-  enqueueMetaEvent(originalName, originalBytes, trimmedFields) {
-    this.queue.push({
-      type: "event",
-      name: "sdk.event_truncated",
-      properties: { originalName, originalBytes, trimmedFields, sdkName: SDK_NAME },
-      environment: this.options.environment,
-      release: this.options.release
-    });
-  }
-  enqueue(payload) {
-    if (this.retry.isDisabled()) {
-      return;
-    }
-    const { payload: trimmed, trimmedFields, originalBytes } = trimEventIfOversized(payload);
-    this.queue.push(trimmed);
-    if (trimmedFields !== null) {
-      this.enqueueMetaEvent(payload.name, originalBytes, trimmedFields);
-    }
-    this.debug("queued payload", {
-      type: payload.type,
-      name: payload.name,
-      queueSize: this.queue.length,
-      flushOnCapture: this.options.flushOnCapture,
-      batchSize: this.options.batchSize
-    });
-    if (this.options.flushOnCapture) {
-      this.debug("capture flush scheduled", {
-        queueSize: this.queue.length
-      });
-      if (!this.retry.isBackingOff()) {
-        this.flush().catch(
-          (err) => this.debug("capture flush error", { error: err })
-        );
-      }
-      return;
-    }
-    if (this.queue.length >= this.options.batchSize && !this.retry.isBackingOff()) {
-      this.flush().catch(
-        (err) => this.debug("batch flush error", { error: err })
-      );
-    }
-  }
-  scheduleFlush() {
-    if (this.flushScheduled) {
-      return;
-    }
-    this.flushScheduled = true;
-    queueMicrotask(() => {
-      this.flushScheduled = false;
-      if (this.queue.length === 0 || this.retry.isBackingOff()) {
-        return;
-      }
-      this.flush().catch(
-        (err) => this.debug("scheduled flush error", { error: err })
-      );
-    });
-  }
-  withDefaults(options) {
-    const {
-      context,
-      deployment,
-      featureFlags,
-      tags,
-      user,
-      environment,
-      release,
-      sessionId,
-      ...rest
-    } = options;
-    return {
-      ...rest,
-      environment: environment ?? this.options.environment,
-      release: release ?? this.options.release,
-      sessionId: sessionId ?? this.options.sessionId,
-      user: user ?? this.user,
-      context: Object.keys(this.context).length ? { ...this.context, ...context } : context,
-      deployment: this.mergeDeployment(deployment),
-      featureFlags: this.mergeFeatureFlags(featureFlags),
-      tags: Object.keys(this.tags).length ? { ...this.tags, ...tags } : tags
-    };
-  }
-  mergeDeployment(deployment) {
-    const merged = {
-      ...this.deployment ?? {},
-      ...deployment ?? {}
-    };
-    return Object.keys(merged).length > 0 ? merged : void 0;
-  }
-  mergeFeatureFlags(featureFlags) {
-    const merged = {
-      ...this.featureFlags,
-      ...featureFlags ?? {}
-    };
-    return Object.keys(merged).length > 0 ? merged : void 0;
-  }
-  handleWindowError = (event) => {
-    const serialized = serializeError(event.error ?? event.message);
-    this.debug("auto-captured window error", {
-      message: serialized.message
-    });
-    this.enqueue({
-      type: "error",
-      name: "error",
-      error: { ...serialized, handled: false },
-      ...this.withDefaults({ context: { source: "window.error" } })
-    });
-  };
-  handlePopState = () => {
-    this.capturePageView();
-  };
-  patchHistoryMethod(method) {
-    const original = history[method].bind(history);
-    history[`__ev_orig_${method}`] = original;
-    history[method] = (...args) => {
-      original(...args);
-      this.capturePageView();
-    };
-  }
-  restoreHistoryMethod(method) {
-    const original = history[`__ev_orig_${method}`];
-    if (original) {
-      history[method] = original;
-    }
-  }
-  handleUnhandledRejection = (event) => {
-    const serialized = serializeError(event.reason);
-    this.debug("auto-captured rejection", {
-      message: serialized.message
-    });
-    this.enqueue({
-      type: "error",
-      name: "error",
-      error: { ...serialized, handled: false },
-      ...this.withDefaults({
-        context: { source: "window.unhandledrejection" }
-      })
-    });
-  };
-  debug(message, payload) {
-    if (!this.options.debug || typeof console.debug !== "function") {
-      return;
-    }
-    const prefix = this.options.label ? `[emit-vision:${this.options.label}]` : "[emit-vision]";
-    if (payload === void 0) {
-      console.debug(prefix, message);
-      return;
-    }
-    console.debug(prefix, message, payload);
+    this.flusher.close();
+    this.autoCapture.detach();
+    debugLog("closed client", this.options);
+  }
+  withDefaults(opts) {
+    return buildWithDefaults(
+      this.user,
+      this.context,
+      this.deployment,
+      this.featureFlags,
+      this.tags,
+      this.options,
+      opts
+    );
   }
 };
 
@@ -714,6 +788,9 @@ function captureError(error, options) {
 function capturePageView(path) {
   requireClient().capturePageView(path);
 }
+function captureFeedback(feedback, options) {
+  requireClient().captureFeedback(feedback, options);
+}
 function identify(userIdOrUser, traits) {
   requireClient().identify(userIdOrUser, traits);
 }
@@ -760,6 +837,7 @@ export {
   captureError,
   captureEvent,
   captureExposure,
+  captureFeedback,
   capturePageView,
   evaluateFlags,
   flush,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@emit-vision/sdk-js",
-  "version": "0.3.0",
+  "version": "0.4.1",
   "description": "Browser SDK for self-hosted emit-vision analytics and error tracking.",
   "private": false,
   "license": "MIT",