@emit-vision/sdk-js 0.2.0 → 0.4.0

package/dist/index.js

@@ -1,519 +1,840 @@
-import { FlushRetryController } from "./retry.js";
-const SDK_NAME = "emit-vision-js";
-const SDK_VERSION = "0.1.0";
-class EmitVisionClient {
-    options;
-    queue = [];
-    user;
-    context = {};
-    deployment;
-    featureFlags = {};
-    tags = {};
-    timer;
-    flushScheduled = false;
-    fetchImpl;
-    flagCache = new Map();
-    retry;
-    constructor(options) {
-        this.options = options;
-        this.fetchImpl = options.fetchImpl;
-        this.deployment = options.deployment
-            ? { ...options.deployment }
-            : undefined;
-        this.featureFlags = options.featureFlags ? { ...options.featureFlags } : {};
-        this.retry = new FlushRetryController({
-            initialMs: options.retryBackoffInitialMs,
-            maxMs: options.retryBackoffMaxMs,
-            failureCap: options.maxConsecutiveFlushFailures,
-        });
-        this.timer = setInterval(() => {
-            if (this.queue.length === 0 || this.retry.isBackingOff()) {
-                return;
-            }
-            this.flush().catch((err) => this.debug("background flush error", { error: err }));
-        }, options.flushIntervalMs);
-        if (options.autoCapture.errors && typeof window !== "undefined") {
-            window.addEventListener("error", this.handleWindowError);
-        }
-        if (options.autoCapture.unhandledRejections &&
-            typeof window !== "undefined") {
-            window.addEventListener("unhandledrejection", this.handleUnhandledRejection);
-        }
-        this.debug("initialized", {
-            endpoint: options.endpoint,
-            environment: options.environment,
-            release: options.release,
-            autoCapture: options.autoCapture,
-            batchSize: options.batchSize,
-            flushIntervalMs: options.flushIntervalMs,
-            flushOnCapture: options.flushOnCapture,
-        });
-    }
-    captureEvent(name, properties, options = {}) {
-        this.debug("queue event", { name, properties, options });
-        this.enqueue({
-            type: "event",
-            name,
-            properties,
-            ...this.withDefaults(options),
-        });
-    }
-    captureError(error, options = {}) {
-        const serialized = serializeError(error);
-        this.debug("queue error", {
-            message: serialized.message,
-            handled: serialized.handled,
-            options,
-        });
-        this.enqueue({
-            type: "error",
-            name: "error",
-            error: serialized,
-            ...this.withDefaults(options),
-        });
+// src/flag-eval.ts
+var FlagEvaluator = class {
+  constructor(cfg, onFlagsLoaded, captureExposure2, debug) {
+    this.cfg = cfg;
+    this.onFlagsLoaded = onFlagsLoaded;
+    this.captureExposure = captureExposure2;
+    this.debug = debug;
+  }
+  cfg;
+  onFlagsLoaded;
+  captureExposure;
+  debug;
+  cache = /* @__PURE__ */ new Map();
+  async evaluateFlags(opts) {
+    const env = opts.environment ?? "";
+    const ttl = opts.ttlMs ?? this.cfg.ttlMs;
+    const key = `${env}:${opts.evaluationKey}`;
+    const cached = this.cache.get(key);
+    if (cached && Date.now() < cached.expiresAt) {
+      this.debug("flag eval cache hit", { key });
+      return cached.flags;
     }
-    identify(userIdOrUser, traits = {}) {
-        this.user =
-            typeof userIdOrUser === "string"
-                ? { id: userIdOrUser, ...traits }
-                : { ...userIdOrUser };
-        this.debug("identified user", this.user);
+    return this.fetchAndCacheFlags(opts, env, ttl, key);
+  }
+  async getFlag(flagKey, fallback, opts) {
+    try {
+      const flags = await this.evaluateFlags(opts);
+      const value = flags[flagKey];
+      return value !== void 0 ? value : fallback;
+    } catch {
+      return fallback;
     }
-    setContext(context) {
-        this.context = { ...this.context, ...context };
-        this.debug("updated context", this.context);
+  }
+  async refreshFlags(opts) {
+    const env = opts.environment ?? "";
+    const ttl = opts.ttlMs ?? this.cfg.ttlMs;
+    const key = `${env}:${opts.evaluationKey}`;
+    this.cache.delete(key);
+    return this.fetchAndCacheFlags(opts, env, ttl, key);
+  }
+  async fetchAndCacheFlags(opts, env, ttl, cacheKey) {
+    let flags = {};
+    let evaluations = {};
+    try {
+      const body = {
+        environment: env,
+        userKey: opts.evaluationKey
+      };
+      if (opts.flagKeys && opts.flagKeys.length > 0) {
+        body.flagKeys = opts.flagKeys;
+      }
+      const response = await this.cfg.fetchImpl(
+        `${this.cfg.endpoint}/v1/flags/evaluate`,
+        {
+          method: "POST",
+          headers: {
+            "content-type": "application/json",
+            "x-emit-api-key": this.cfg.apiKey
+          },
+          body: JSON.stringify(body)
+        }
+      );
+      if (response.ok) {
+        const data = await response.json();
+        evaluations = data.evaluations;
+        flags = Object.fromEntries(
+          Object.entries(evaluations).map(([k, v]) => [k, v.variantValue])
+        );
+        this.debug("flag eval complete", { count: Object.keys(flags).length });
+      } else {
+        this.debug("flag eval response error", { status: response.status });
+      }
+    } catch (err) {
+      this.debug("flag eval network error", { error: err });
     }
-    setDeploymentContext(context) {
-        this.deployment =
-            Object.keys(context).length > 0 ? { ...context } : undefined;
-        this.debug("updated deployment context", this.deployment);
+    this.cache.set(cacheKey, { flags, expiresAt: Date.now() + ttl });
+    this.onFlagsLoaded(flags);
+    if (this.cfg.flagExposures) {
+      for (const [flagKey, entry] of Object.entries(evaluations)) {
+        this.captureExposure(
+          flagKey,
+          entry.variantKey,
+          entry.variantValue,
+          entry.reason,
+          env
+        );
+      }
     }
-    setFeatureFlags(featureFlags) {
-        this.featureFlags = { ...featureFlags };
-        this.debug("updated feature flags", this.featureFlags);
+    return flags;
+  }
+};
+
+// src/util.ts
+function parseDsn(dsn) {
+  const parsed = new URL(dsn);
+  const apiKey = decodeURIComponent(parsed.username);
+  if (!apiKey) {
+    throw new Error("emit-vision dsn must include the API key before the @");
+  }
+  const pathname = stripTrailingSlash(parsed.pathname) ?? "";
+  const endpointPath = pathname.endsWith("/v1") ? pathname.slice(0, -"/v1".length) : pathname;
+  return {
+    apiKey,
+    endpoint: stripTrailingSlash(`${parsed.origin}${endpointPath}`)
+  };
+}
+function stripTrailingSlash(value) {
+  if (!value) {
+    return value;
+  }
+  return value.endsWith("/") ? value.slice(0, -1) : value;
+}
+function serializeError(error) {
+  if (error instanceof Error) {
+    return {
+      message: error.message,
+      name: error.name,
+      stack: error.stack,
+      handled: true
+    };
+  }
+  return {
+    message: typeof error === "string" ? error : JSON.stringify(error),
+    handled: true
+  };
+}
+function resolveTransport(options) {
+  const dsn = options.dsn ? parseDsn(options.dsn) : null;
+  const apiKey = options.apiKey ?? dsn?.apiKey;
+  if (!apiKey) {
+    throw new Error("emit-vision init requires either apiKey or dsn");
+  }
+  return {
+    apiKey,
+    endpoint: stripTrailingSlash(options.endpoint ?? dsn?.endpoint)
+  };
+}
+var ANON_ID_KEY = "__ev_anon_id";
+function getOrCreateAnonymousId() {
+  try {
+    const stored = localStorage.getItem(ANON_ID_KEY);
+    if (stored) return stored;
+    const id = crypto.randomUUID();
+    localStorage.setItem(ANON_ID_KEY, id);
+    return id;
+  } catch {
+    return void 0;
+  }
+}
+function resolveAutoCapture(options) {
+  const legacyDefault = options.autoCaptureErrors === void 0 ? true : options.autoCaptureErrors;
+  return {
+    errors: options.autoCapture?.errors ?? legacyDefault,
+    unhandledRejections: options.autoCapture?.unhandledRejections ?? legacyDefault,
+    flagExposures: options.autoCapture?.flagExposures ?? true,
+    pageViews: options.autoCapture?.pageViews ?? false
+  };
+}
+
+// src/client-helpers.ts
+var SDK_NAME = "emit-vision-js";
+var SDK_VERSION = "0.4.0";
+var MAX_EVENT_BYTES = 64 * 1024;
+var MAX_BATCH_BYTES = 1 * 1024 * 1024;
+function byteLength(s) {
+  return new TextEncoder().encode(s).length;
+}
+function trimEventIfOversized(payload) {
+  const json = JSON.stringify(payload);
+  const originalBytes = byteLength(json);
+  if (originalBytes <= MAX_EVENT_BYTES) {
+    return { payload, trimmedFields: null, originalBytes };
+  }
+  const propBytes = payload.properties ? byteLength(JSON.stringify(payload.properties)) : 0;
+  const ctxBytes = payload.context ? byteLength(JSON.stringify(payload.context)) : 0;
+  if (typeof console.warn === "function") {
+    console.warn(
+      `[emit-vision] event truncated \u2014 "${payload.name}" was ${originalBytes} bytes (max ${MAX_EVENT_BYTES}); properties/context trimmed.`
+    );
+  }
+  const trimmedFields = [];
+  if (propBytes > 0) trimmedFields.push("properties");
+  if (ctxBytes > 0) trimmedFields.push("context");
+  if (payload.type === "error" && payload.error.stack) {
+    trimmedFields.push("error.stack");
+  }
+  const base = {
+    properties: propBytes > 0 ? { _truncated: true, _originalBytes: propBytes } : void 0,
+    context: ctxBytes > 0 ? { _truncated: true, _originalBytes: ctxBytes } : void 0
+  };
+  if (payload.type === "error") {
+    return {
+      payload: {
+        ...payload,
+        ...base,
+        error: { ...payload.error, stack: void 0 }
+      },
+      trimmedFields,
+      originalBytes
+    };
+  }
+  return { payload: { ...payload, ...base }, trimmedFields, originalBytes };
+}
+function buildBatchBody(chunk) {
+  return JSON.stringify({
+    events: chunk.map((item) => ({
+      ...item,
+      sdk: { name: SDK_NAME, version: SDK_VERSION }
+    }))
+  });
+}
+function splitBatch(batch) {
+  if (batch.length <= 1) return [batch];
+  const body = buildBatchBody(batch);
+  if (byteLength(body) <= MAX_BATCH_BYTES) return [batch];
+  const mid = Math.floor(batch.length / 2);
+  return [...splitBatch(batch.slice(0, mid)), ...splitBatch(batch.slice(mid))];
+}
+
+// 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
+      };
     }
-    /**
-     * Fetch and evaluate all active flags for the given evaluation key.
-     * Results are cached for `ttlMs` (defaults to `flagEvalTtlMs` from init options).
-     * On network failure returns an empty object and does not throw.
-     * Evaluated variants are automatically merged into the SDK's feature-flag context.
-     */
-    async evaluateFlags(opts) {
-        const env = opts.environment ?? this.options.environment ?? "";
-        const ttl = opts.ttlMs ?? this.options.flagEvalTtlMs;
-        const key = `${env}:${opts.evaluationKey}`;
-        const cached = this.flagCache.get(key);
-        if (cached && Date.now() < cached.expiresAt) {
-            this.debug("flag eval cache hit", { key });
-            return cached.flags;
-        }
-        return this.fetchAndCacheFlags(opts, env, ttl, key);
+    if (this.opts.initialMs <= 0) {
+      this.backoffUntil = 0;
+      return {
+        backoffMs: 0,
+        consecutiveFailures: this.consecutiveFailures,
+        justDisabled: false
+      };
     }
-    /**
-     * Return a single flag's value, evaluated for the given key.
-     * Returns `fallback` on network failure or when the flag is not found — never throws.
-     */
-    async getFlag(flagKey, fallback, opts) {
-        try {
-            const flags = await this.evaluateFlags(opts);
-            const value = flags[flagKey];
-            return (value !== undefined ? value : fallback);
-        }
-        catch {
-            return fallback;
-        }
+    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 = fetchImpl;
+    this.retry = new FlushRetryController({
+      initialMs: options.retryBackoffInitialMs,
+      maxMs: options.retryBackoffMaxMs,
+      failureCap: options.maxConsecutiveFlushFailures
+    });
+    this.timer = setInterval(() => {
+      if (this.queue.length === 0 || this.retry.isBackingOff()) return;
+      this.flush().catch(
+        (err) => debugLog("background flush error", this.options, { error: err })
+      );
+    }, options.flushIntervalMs);
+  }
+  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);
     }
-    /**
-     * Bypass the cache and re-fetch evaluations for the given key.
-     * Useful after a flag change in the dashboard that should apply immediately.
-     */
-    async refreshFlags(opts) {
-        const env = opts.environment ?? this.options.environment ?? "";
-        const ttl = opts.ttlMs ?? this.options.flagEvalTtlMs;
-        const key = `${env}:${opts.evaluationKey}`;
-        this.flagCache.delete(key);
-        return this.fetchAndCacheFlags(opts, env, ttl, key);
+    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;
     }
-    captureExposure(flagKey, variantKey, variantValue, reason, environment) {
-        this.captureEvent("$flag_exposure", {
-            flagKey,
-            variantKey,
-            ...(variantValue !== undefined ? { variantValue } : {}),
-            ...(reason ? { reason } : {}),
-            environment: environment ?? this.options.environment,
-        });
+    if (this.queue.length >= this.options.batchSize && !this.retry.isBackingOff()) {
+      this.flush().catch(
+        (err) => debugLog("batch flush error", this.options, { error: err })
+      );
     }
-    async fetchAndCacheFlags(opts, env, ttl, cacheKey) {
-        let flags = {};
-        let evaluations = {};
-        try {
-            const body = {
-                environment: env,
-                userKey: opts.evaluationKey,
-            };
-            if (opts.flagKeys && opts.flagKeys.length > 0) {
-                body.flagKeys = opts.flagKeys;
-            }
-            const response = await this.fetchImpl(`${this.options.endpoint}/v1/flags/evaluate`, {
-                method: "POST",
-                headers: {
-                    "content-type": "application/json",
-                    "x-emit-api-key": this.options.apiKey,
-                },
-                body: JSON.stringify(body),
-            });
-            if (response.ok) {
-                const data = (await response.json());
-                evaluations = data.evaluations;
-                flags = Object.fromEntries(Object.entries(evaluations).map(([k, v]) => [k, v.variantValue]));
-                this.debug("flag eval complete", { count: Object.keys(flags).length });
-            }
-            else {
-                this.debug("flag eval response error", { status: response.status });
-            }
-        }
-        catch (err) {
-            this.debug("flag eval network error", { error: err });
-            // Return empty flags on network error — never throw to callers
-        }
-        this.flagCache.set(cacheKey, { flags, expiresAt: Date.now() + ttl });
-        // Merge evaluated variants into the existing feature-flag context so that
-        // subsequent captureEvent / captureError calls include them automatically.
-        this.featureFlags = { ...this.featureFlags, ...flags };
-        if (this.options.autoCapture.flagExposures) {
-            for (const [flagKey, entry] of Object.entries(evaluations)) {
-                this.captureExposure(flagKey, entry.variantKey, entry.variantValue, entry.reason, env);
-            }
+  }
+  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);
+          }
         }
-        return flags;
+        throw err;
+      }
     }
-    setTags(tags) {
-        this.tags = { ...this.tags, ...tags };
-        this.debug("updated tags", this.tags);
+    if (this.options.flushOnCapture && this.queue.length > 0) {
+      this.scheduleFlush();
     }
-    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 });
-        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: JSON.stringify({
-                    events: batch.map((item) => ({
-                        ...item,
-                        sdk: { name: SDK_NAME, version: SDK_VERSION },
-                    })),
-                }),
-                keepalive: true,
-            });
-        }
-        catch (err) {
-            this.handleFlushFailure(batch, { reason: "network", error: err });
-            throw err;
-        }
-        if (!response.ok) {
-            const error = new Error(`emit-vision flush failed with ${response.status}`);
-            this.handleFlushFailure(batch, {
-                reason: "status",
-                status: response.status,
-            });
-            throw error;
-        }
-        this.retry.reset();
-        this.debug("flush complete", { count: batch.length });
-        if (this.options.flushOnCapture && this.queue.length > 0) {
-            this.scheduleFlush();
-        }
+  }
+  close() {
+    if (this.timer) {
+      clearInterval(this.timer);
+      this.timer = void 0;
     }
-    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,
-            });
-        }
+  }
+  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;
     }
-    stopBackgroundWork() {
-        if (this.timer) {
-            clearInterval(this.timer);
-            this.timer = undefined;
-        }
+    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;
     }
-    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);
-        }
-        this.debug("closed client");
+    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
+      });
     }
-    enqueue(payload) {
-        if (this.retry.isDisabled()) {
-            return;
-        }
-        this.queue.push(payload);
-        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) => 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);
     }
-    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 }));
-        });
+    if (this.config.unhandledRejections) {
+      window.addEventListener(
+        "unhandledrejection",
+        this.handleUnhandledRejection
+      );
     }
-    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,
-        };
+    if (this.config.pageViews) {
+      this.onPageView();
+      window.addEventListener("popstate", this.handlePopState);
+      this.patchHistoryMethod("pushState");
+      this.patchHistoryMethod("replaceState");
     }
-    mergeDeployment(deployment) {
-        const merged = {
-            ...(this.deployment ?? {}),
-            ...(deployment ?? {}),
-        };
-        return Object.keys(merged).length > 0 ? merged : undefined;
+  }
+  detach() {
+    if (typeof window === "undefined") return;
+    if (this.config.errors) {
+      window.removeEventListener("error", this.handleWindowError);
     }
-    mergeFeatureFlags(featureFlags) {
-        const merged = {
-            ...this.featureFlags,
-            ...(featureFlags ?? {}),
-        };
-        return Object.keys(merged).length > 0 ? merged : undefined;
+    if (this.config.unhandledRejections) {
+      window.removeEventListener(
+        "unhandledrejection",
+        this.handleUnhandledRejection
+      );
     }
-    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" } }),
-        });
-    };
-    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;
+    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
         }
-        const prefix = this.options.label
-            ? `[emit-vision:${this.options.label}]`
-            : "[emit-vision]";
-        if (payload === undefined) {
-            console.debug(prefix, message);
-            return;
+      })
+    });
+  };
+  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
         }
-        console.debug(prefix, message, payload);
+      })
+    });
+  };
+  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;
     }
-}
-let client;
-export function init(options) {
-    const transport = resolveTransport(options);
-    const autoCapture = resolveAutoCapture(options);
-    client?.close();
-    client = new EmitVisionClient({
-        ...options,
-        flushIntervalMs: options.flushIntervalMs ?? 5000,
-        batchSize: options.batchSize ?? 20,
-        debug: options.debug ?? false,
-        fetchImpl: options.fetchImpl ?? globalThis.fetch.bind(globalThis),
-        flushOnCapture: options.flushOnCapture ?? false,
-        flagEvalTtlMs: options.flagEvalTtlMs ?? 60_000,
-        retryBackoffInitialMs: options.retryBackoffInitialMs ?? 1_000,
-        retryBackoffMaxMs: options.retryBackoffMaxMs ?? 30_000,
-        maxConsecutiveFlushFailures: options.maxConsecutiveFlushFailures ?? 20,
-        apiKey: transport.apiKey,
-        endpoint: transport.endpoint ?? options.endpoint ?? "http://localhost:4301",
-        autoCapture,
+  }
+};
+
+// 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,
+      autoCapture: options.autoCapture,
+      batchSize: options.batchSize,
+      flushIntervalMs: options.flushIntervalMs,
+      flushOnCapture: options.flushOnCapture
     });
-    return client;
-}
-export function captureEvent(name, properties, options) {
-    requireClient().captureEvent(name, properties, options);
-}
-export function captureError(error, options) {
-    requireClient().captureError(error, options);
-}
-export function identify(userIdOrUser, traits) {
-    requireClient().identify(userIdOrUser, traits);
-}
-export function setContext(context) {
-    requireClient().setContext(context);
+  }
+  options;
+  user;
+  context = {};
+  deployment;
+  featureFlags = {};
+  tags = {};
+  flagEval;
+  autoCapture;
+  flusher;
+  captureEvent(name, properties, options = {}) {
+    debugLog("queue event", this.options, { name, properties, options });
+    this.flusher.enqueue({
+      type: "event",
+      name,
+      properties,
+      ...this.withDefaults(options)
+    });
+  }
+  captureError(error, options = {}) {
+    const serialized = serializeError(error);
+    debugLog("queue error", this.options, {
+      message: serialized.message,
+      options
+    });
+    this.flusher.enqueue({
+      type: "error",
+      name: "error",
+      error: serialized,
+      ...this.withDefaults(options)
+    });
+  }
+  identify(userIdOrUser, traits = {}) {
+    this.user = typeof userIdOrUser === "string" ? { id: userIdOrUser, ...traits } : { ...userIdOrUser };
+    debugLog("identified user", this.options, this.user);
+  }
+  setContext(context) {
+    this.context = { ...this.context, ...context };
+    debugLog("updated context", this.options, this.context);
+  }
+  setDeploymentContext(context) {
+    this.deployment = Object.keys(context).length > 0 ? { ...context } : void 0;
+    debugLog("updated deployment context", this.options, this.deployment);
+  }
+  setFeatureFlags(featureFlags) {
+    this.featureFlags = { ...featureFlags };
+    debugLog("updated feature flags", this.options, this.featureFlags);
+  }
+  evaluateFlags(opts) {
+    return this.flagEval.evaluateFlags({
+      ...opts,
+      environment: opts.environment ?? this.options.environment
+    });
+  }
+  getFlag(flagKey, fallback, opts) {
+    return this.flagEval.getFlag(flagKey, fallback, {
+      ...opts,
+      environment: opts.environment ?? this.options.environment
+    });
+  }
+  refreshFlags(opts) {
+    return this.flagEval.refreshFlags({
+      ...opts,
+      environment: opts.environment ?? this.options.environment
+    });
+  }
+  capturePageView(path) {
+    const page = path ?? (typeof window !== "undefined" ? window.location.pathname : void 0);
+    if (!page) return;
+    this.captureEvent("$page_view", { page });
+  }
+  captureExposure(flagKey, variantKey, variantValue, reason, environment) {
+    this.captureEvent("$flag_exposure", {
+      flagKey,
+      variantKey,
+      ...variantValue !== void 0 ? { variantValue } : {},
+      ...reason ? { reason } : {},
+      environment: environment ?? this.options.environment
+    });
+  }
+  setTags(tags) {
+    this.tags = { ...this.tags, ...tags };
+    debugLog("updated tags", this.options, this.tags);
+  }
+  flush() {
+    return this.flusher.flush();
+  }
+  close() {
+    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
+    );
+  }
+};
+
+// src/index.ts
+var client;
+function init(options) {
+  const transport = resolveTransport(options);
+  const autoCapture = resolveAutoCapture(options);
+  const resolved = {
+    ...options,
+    flushIntervalMs: options.flushIntervalMs ?? 5e3,
+    batchSize: options.batchSize ?? 20,
+    debug: options.debug ?? false,
+    fetchImpl: options.fetchImpl ?? globalThis.fetch.bind(globalThis),
+    flushOnCapture: options.flushOnCapture ?? false,
+    flagEvalTtlMs: options.flagEvalTtlMs ?? 6e4,
+    retryBackoffInitialMs: options.retryBackoffInitialMs ?? 1e3,
+    retryBackoffMaxMs: options.retryBackoffMaxMs ?? 3e4,
+    maxConsecutiveFlushFailures: options.maxConsecutiveFlushFailures ?? 20,
+    apiKey: transport.apiKey,
+    endpoint: transport.endpoint ?? options.endpoint ?? "http://localhost:4301",
+    autoCapture,
+    sessionId: options.sessionId ?? getOrCreateAnonymousId()
+  };
+  client?.close();
+  client = new EmitVisionClient(resolved);
+  return client;
 }
-export function setDeploymentContext(context) {
-    requireClient().setDeploymentContext(context);
+function captureEvent(name, properties, options) {
+  requireClient().captureEvent(name, properties, options);
 }
-export function setFeatureFlags(featureFlags) {
-    requireClient().setFeatureFlags(featureFlags);
+function captureError(error, options) {
+  requireClient().captureError(error, options);
 }
-export function setTags(tags) {
-    requireClient().setTags(tags);
+function capturePageView(path) {
+  requireClient().capturePageView(path);
 }
-export async function flush() {
-    await requireClient().flush();
+function identify(userIdOrUser, traits) {
+  requireClient().identify(userIdOrUser, traits);
 }
-export async function evaluateFlags(options) {
-    return requireClient().evaluateFlags(options);
+function setContext(context) {
+  requireClient().setContext(context);
 }
-export async function getFlag(flagKey, fallback, options) {
-    return requireClient().getFlag(flagKey, fallback, options);
+function setDeploymentContext(context) {
+  requireClient().setDeploymentContext(context);
 }
-export async function refreshFlags(options) {
-    return requireClient().refreshFlags(options);
+function setFeatureFlags(featureFlags) {
+  requireClient().setFeatureFlags(featureFlags);
 }
-export function captureExposure(flagKey, variantKey, variantValue, reason, environment) {
-    requireClient().captureExposure(flagKey, variantKey, variantValue, reason, environment);
+function setTags(tags) {
+  requireClient().setTags(tags);
 }
-function requireClient() {
-    if (!client) {
-        throw new Error("emit-vision SDK has not been initialized");
-    }
-    return client;
+async function flush() {
+  await requireClient().flush();
 }
-function resolveTransport(options) {
-    const dsn = options.dsn ? parseDsn(options.dsn) : null;
-    const apiKey = options.apiKey ?? dsn?.apiKey;
-    if (!apiKey) {
-        throw new Error("emit-vision init requires either apiKey or dsn");
-    }
-    return {
-        apiKey,
-        endpoint: stripTrailingSlash(options.endpoint ?? dsn?.endpoint),
-    };
+async function evaluateFlags(options) {
+  return requireClient().evaluateFlags(options);
 }
-function resolveAutoCapture(options) {
-    const legacyDefault = options.autoCaptureErrors === undefined ? true : options.autoCaptureErrors;
-    return {
-        errors: options.autoCapture?.errors ?? legacyDefault,
-        unhandledRejections: options.autoCapture?.unhandledRejections ?? legacyDefault,
-        flagExposures: options.autoCapture?.flagExposures ?? true,
-    };
+async function getFlag(flagKey, fallback, options) {
+  return requireClient().getFlag(flagKey, fallback, options);
 }
-function parseDsn(dsn) {
-    const parsed = new URL(dsn);
-    const apiKey = decodeURIComponent(parsed.username);
-    if (!apiKey) {
-        throw new Error("emit-vision dsn must include the API key before the @");
-    }
-    const pathname = stripTrailingSlash(parsed.pathname) ?? "";
-    const endpointPath = pathname.endsWith("/v1")
-        ? pathname.slice(0, -"/v1".length)
-        : pathname;
-    return {
-        apiKey,
-        endpoint: stripTrailingSlash(`${parsed.origin}${endpointPath}`),
-    };
+async function refreshFlags(options) {
+  return requireClient().refreshFlags(options);
 }
-function stripTrailingSlash(value) {
-    if (!value) {
-        return value;
-    }
-    return value.endsWith("/") ? value.slice(0, -1) : value;
+function captureExposure(flagKey, variantKey, variantValue, reason, environment) {
+  requireClient().captureExposure(
+    flagKey,
+    variantKey,
+    variantValue,
+    reason,
+    environment
+  );
 }
-function serializeError(error) {
-    if (error instanceof Error) {
-        return {
-            message: error.message,
-            name: error.name,
-            stack: error.stack,
-            handled: true,
-        };
-    }
-    return {
-        message: typeof error === "string" ? error : JSON.stringify(error),
-        handled: true,
-    };
+function requireClient() {
+  if (!client) {
+    throw new Error("emit-vision SDK has not been initialized");
+  }
+  return client;
 }
+export {
+  captureError,
+  captureEvent,
+  captureExposure,
+  capturePageView,
+  evaluateFlags,
+  flush,
+  getFlag,
+  identify,
+  init,
+  refreshFlags,
+  setContext,
+  setDeploymentContext,
+  setFeatureFlags,
+  setTags
+};