@emit-vision/sdk-js 0.3.0 → 0.4.0

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;
@@ -103,22 +100,8 @@ declare class EmitVisionClient {
     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;

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({
@@ -413,270 +723,26 @@ var EmitVisionClient = class {
   }
   setTags(tags) {
     this.tags = { ...this.tags, ...tags };
-    this.debug("updated tags", 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();
-    }
+    debugLog("updated tags", this.options, this.tags);
   }
-  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
+    );
   }
 };
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@emit-vision/sdk-js",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "description": "Browser SDK for self-hosted emit-vision analytics and error tracking.",
   "private": false,
   "license": "MIT",
@@ -34,6 +34,7 @@
     }
   },
   "scripts": {
-    "build": "tsup --config tsup.config.ts"
+    "build": "tsup --config tsup.config.ts",
+    "prepack": "pnpm run build"
   }
-}
+}