@koderlabs/tasks-sdk 0.1.0

package/dist/index.cjs

@@ -0,0 +1,908 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  Client: () => Client,
+  captureWebVitals: () => captureWebVitals,
+  defaultScrubEvent: () => defaultScrubEvent,
+  getClient: () => getClient,
+  init: () => init,
+  newSpanId: () => newSpanId,
+  newTraceId: () => newTraceId,
+  signRequest: () => signRequest
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/transport.ts
+var REQUEST_TIMEOUT_MS = 1e4;
+var MAX_EVENT_BYTES = 500 * 1024;
+var PayloadTooLargeError = class PayloadTooLargeError2 extends Error {
+  static {
+    __name(this, "PayloadTooLargeError");
+  }
+  bytes;
+  constructor(bytes) {
+    super(`InstantTasks SDK payload too large: ${bytes} bytes (max ${MAX_EVENT_BYTES})`), this.bytes = bytes;
+    this.name = "PayloadTooLargeError";
+  }
+};
+function timeoutSignal(ms) {
+  if (typeof AbortSignal !== "undefined" && typeof AbortSignal.timeout === "function") {
+    return AbortSignal.timeout(ms);
+  }
+  const ctrl = new AbortController();
+  setTimeout(() => ctrl.abort(), ms);
+  return ctrl.signal;
+}
+__name(timeoutSignal, "timeoutSignal");
+function pickFetch(opts) {
+  return opts?.fetch ?? globalThis.fetch;
+}
+__name(pickFetch, "pickFetch");
+async function signRequest(body, secret) {
+  const ts = String(Date.now());
+  const nonce = typeof crypto !== "undefined" && "randomUUID" in crypto ? crypto.randomUUID() : `${Date.now()}-${Math.random().toString(36).slice(2)}`;
+  try {
+    const subtle = globalThis.crypto?.subtle;
+    if (!subtle) return {};
+    const enc = new TextEncoder();
+    const hashBuf = await subtle.digest("SHA-256", enc.encode(body));
+    const bodyHash = bufToHex(hashBuf);
+    const key = await subtle.importKey("raw", enc.encode(secret), {
+      name: "HMAC",
+      hash: "SHA-256"
+    }, false, [
+      "sign"
+    ]);
+    const sigBuf = await subtle.sign("HMAC", key, enc.encode(`${ts}.${nonce}.${bodyHash}`));
+    return {
+      "X-IT-Timestamp": ts,
+      "X-IT-Nonce": nonce,
+      "X-IT-Signature": bufToHex(sigBuf)
+    };
+  } catch {
+    return {};
+  }
+}
+__name(signRequest, "signRequest");
+function bufToHex(buf) {
+  const bytes = new Uint8Array(buf);
+  let hex = "";
+  for (let i = 0; i < bytes.length; i++) hex += bytes[i].toString(16).padStart(2, "0");
+  return hex;
+}
+__name(bufToHex, "bufToHex");
+async function postSpans(endpoint, projectId, accessKey, spans, opts) {
+  if (!spans.length) return {
+    accepted: 0
+  };
+  const url = `${endpoint}/api/v1/sdk/v1/spans`;
+  const body = JSON.stringify({
+    spans
+  });
+  const headers = {
+    Authorization: `Bearer ${accessKey}`,
+    "X-Project-Id": projectId,
+    "Content-Type": "application/json"
+  };
+  if (opts?.signingSecret) Object.assign(headers, await signRequest(body, opts.signingSecret));
+  const f = pickFetch(opts);
+  const res = await f(url, {
+    method: "POST",
+    headers,
+    body,
+    signal: timeoutSignal(REQUEST_TIMEOUT_MS)
+  });
+  if (!res.ok) {
+    const text = (await res.text().catch(() => "")).slice(0, 512);
+    throw new Error(`InstantTasks SDK spans ingest failed: ${res.status} ${text}`);
+  }
+  return await res.json();
+}
+__name(postSpans, "postSpans");
+async function postEvent(endpoint, projectId, accessKey, event, attachments, opts) {
+  const hasAttachments = !!attachments && attachments.size > 0;
+  const url = `${endpoint}/api/v1/sdk/events${hasAttachments ? "/multipart" : ""}`;
+  const headers = {
+    Authorization: `Bearer ${accessKey}`,
+    "X-Project-Id": projectId
+  };
+  let body;
+  let signedBody = null;
+  if (hasAttachments) {
+    const form = new FormData();
+    const eventJson = JSON.stringify(event);
+    if (eventJson.length > MAX_EVENT_BYTES) throw new PayloadTooLargeError(eventJson.length);
+    form.append("event", eventJson);
+    for (const [name, blob] of attachments) form.append(name, blob, name);
+    body = form;
+  } else {
+    headers["Content-Type"] = "application/json";
+    const json = JSON.stringify(event);
+    if (json.length > MAX_EVENT_BYTES) throw new PayloadTooLargeError(json.length);
+    signedBody = json;
+    body = json;
+  }
+  if (opts?.signingSecret && signedBody !== null) {
+    Object.assign(headers, await signRequest(signedBody, opts.signingSecret));
+  }
+  const f = pickFetch(opts);
+  const res = await f(url, {
+    method: "POST",
+    headers,
+    body,
+    signal: timeoutSignal(REQUEST_TIMEOUT_MS)
+  });
+  if (!res.ok) {
+    const text = (await res.text().catch(() => "")).slice(0, 512);
+    const err = new TransportHttpError(res.status, text, res.headers.get("retry-after"));
+    throw err;
+  }
+  return await res.json();
+}
+__name(postEvent, "postEvent");
+var TransportHttpError = class extends Error {
+  static {
+    __name(this, "TransportHttpError");
+  }
+  status;
+  body;
+  retryAfter;
+  constructor(status, body, retryAfter) {
+    super(`InstantTasks SDK ingest failed: ${status} ${body}`), this.status = status, this.body = body, this.retryAfter = retryAfter;
+    this.name = "TransportHttpError";
+  }
+};
+
+// src/scrubber.ts
+var REDACTED = "[REDACTED]";
+var MAX_DEPTH = 5;
+var MAX_BYTES = 50 * 1024;
+var SECRET_HEADER_NAMES = /* @__PURE__ */ new Set([
+  "authorization",
+  "cookie",
+  "set-cookie",
+  "proxy-authorization"
+]);
+var SECRET_KEY_NAMES = /* @__PURE__ */ new Set([
+  "password",
+  "secret",
+  "token",
+  "apikey",
+  "api_key",
+  "auth",
+  "session"
+]);
+var SECRET_QUERY_PARAMS = /* @__PURE__ */ new Set([
+  "token",
+  "access_token",
+  "refresh_token",
+  "password",
+  "api_key",
+  "apikey",
+  "secret",
+  "key",
+  "auth",
+  "session",
+  "code",
+  "state"
+]);
+function isSecretHeaderName(name) {
+  return SECRET_HEADER_NAMES.has(name.toLowerCase());
+}
+__name(isSecretHeaderName, "isSecretHeaderName");
+function isSecretKeyName(name) {
+  return SECRET_KEY_NAMES.has(name.toLowerCase());
+}
+__name(isSecretKeyName, "isSecretKeyName");
+function redactUrl(input) {
+  if (typeof input !== "string") return input;
+  if (!input.includes("?")) return input;
+  try {
+    const u = new URL(input, "http://_scrub_base_/");
+    let changed = false;
+    const params = u.searchParams;
+    const keys = [];
+    params.forEach((_v, k) => {
+      keys.push(k);
+    });
+    for (const k of keys) {
+      if (SECRET_QUERY_PARAMS.has(k.toLowerCase())) {
+        params.set(k, REDACTED);
+        changed = true;
+      }
+    }
+    if (!changed) return input;
+    if (input.startsWith("http://") || input.startsWith("https://")) return u.toString();
+    return u.pathname + (u.search ? u.search : "") + (u.hash || "");
+  } catch {
+    return input;
+  }
+}
+__name(redactUrl, "redactUrl");
+function cloneAndScrub(value, depth, seen, parentKey) {
+  if (depth > MAX_DEPTH) return value;
+  if (value === null || value === void 0) return value;
+  if (typeof value !== "object") {
+    if (typeof value === "string") return redactUrl(value);
+    return value;
+  }
+  if (seen.has(value)) return "[Circular]";
+  seen.add(value);
+  if (Array.isArray(value)) {
+    return value.map((item) => cloneAndScrub(item, depth + 1, seen, parentKey));
+  }
+  const out = {};
+  for (const [k, v] of Object.entries(value)) {
+    if (isSecretKeyName(k)) {
+      out[k] = REDACTED;
+      continue;
+    }
+    if (parentKey && parentKey.toLowerCase() === "headers" && isSecretHeaderName(k)) {
+      out[k] = REDACTED;
+      continue;
+    }
+    if (typeof v === "string" && (k === "url" || k === "href" || k === "location")) {
+      out[k] = redactUrl(v);
+      continue;
+    }
+    out[k] = cloneAndScrub(v, depth + 1, seen, k);
+  }
+  return out;
+}
+__name(cloneAndScrub, "cloneAndScrub");
+function deepClone(value) {
+  if (typeof globalThis.structuredClone === "function") {
+    try {
+      return globalThis.structuredClone(value);
+    } catch {
+    }
+  }
+  return JSON.parse(JSON.stringify(value));
+}
+__name(deepClone, "deepClone");
+function defaultScrubEvent(event) {
+  try {
+    const approxSize = JSON.stringify(event).length;
+    if (approxSize > MAX_BYTES) return event;
+  } catch {
+    return event;
+  }
+  const cloned = deepClone(event);
+  const scrubbed = cloneAndScrub(cloned, 0, /* @__PURE__ */ new WeakSet());
+  if (scrubbed && typeof scrubbed === "object" && scrubbed.url) {
+    scrubbed.url = redactUrl(scrubbed.url);
+  }
+  return scrubbed;
+}
+__name(defaultScrubEvent, "defaultScrubEvent");
+
+// src/internal-logger.ts
+function isProd() {
+  try {
+    const proc = globalThis.process;
+    return proc?.env?.NODE_ENV === "production";
+  } catch {
+    return false;
+  }
+}
+__name(isProd, "isProd");
+function emit(level, debug, args) {
+  if (!debug) return;
+  if (isProd()) return;
+  const fn = console[level];
+  if (typeof fn === "function") fn("[InstantTasks]", ...args);
+}
+__name(emit, "emit");
+function debugLog(enabled, ...args) {
+  emit("log", enabled, args);
+}
+__name(debugLog, "debugLog");
+function debugWarn(enabled, ...args) {
+  emit("warn", enabled, args);
+}
+__name(debugWarn, "debugWarn");
+function internalError(message, err) {
+  try {
+    console.error("[InstantTasks]", message, err);
+  } catch {
+  }
+}
+__name(internalError, "internalError");
+
+// src/spans.ts
+function randomHex(bytes) {
+  const arr = new Uint8Array(bytes);
+  if (typeof crypto !== "undefined" && crypto.getRandomValues) {
+    crypto.getRandomValues(arr);
+  } else {
+    for (let i = 0; i < bytes; i++) arr[i] = Math.floor(Math.random() * 256);
+  }
+  return Array.from(arr, (b) => b.toString(16).padStart(2, "0")).join("");
+}
+__name(randomHex, "randomHex");
+function newTraceId() {
+  return randomHex(16);
+}
+__name(newTraceId, "newTraceId");
+function newSpanId() {
+  return randomHex(8);
+}
+__name(newSpanId, "newSpanId");
+var SpanExporter = class {
+  static {
+    __name(this, "SpanExporter");
+  }
+  endpoint;
+  projectId;
+  accessKey;
+  debug;
+  transportOpts;
+  queue = [];
+  timer = null;
+  FLUSH_MS = 5e3;
+  MAX_QUEUE = 50;
+  constructor(endpoint, projectId, accessKey, debug = false, transportOpts = {}) {
+    this.endpoint = endpoint;
+    this.projectId = projectId;
+    this.accessKey = accessKey;
+    this.debug = debug;
+    this.transportOpts = transportOpts;
+  }
+  start() {
+    if (this.timer) return;
+    this.timer = setInterval(() => {
+      void this.flush();
+    }, this.FLUSH_MS);
+  }
+  stop() {
+    if (this.timer) {
+      clearInterval(this.timer);
+      this.timer = null;
+    }
+  }
+  enqueue(span) {
+    this.queue.push(span);
+    if (this.queue.length >= this.MAX_QUEUE) void this.flush();
+  }
+  async flush() {
+    if (!this.queue.length) return;
+    const batch = this.queue.splice(0, this.queue.length);
+    try {
+      await postSpans(this.endpoint, this.projectId, this.accessKey, batch, this.transportOpts);
+    } catch (err) {
+      debugWarn(this.debug, "span flush failed", err);
+    }
+  }
+};
+function startSpan(exporter, opts) {
+  const traceId = opts.traceId ?? newTraceId();
+  const spanId = newSpanId();
+  const startedAt = Date.now();
+  let attrs = {
+    ...opts.attrs ?? {}
+  };
+  let ended = false;
+  return {
+    traceId,
+    spanId,
+    parentSpanId: opts.parentSpanId,
+    setAttr(key, value) {
+      attrs[key] = value;
+    },
+    end(closeOpts) {
+      if (ended) return;
+      ended = true;
+      const endedAt = Date.now();
+      if (closeOpts?.attrs) attrs = {
+        ...attrs,
+        ...closeOpts.attrs
+      };
+      exporter.enqueue({
+        traceId,
+        spanId,
+        parentSpanId: opts.parentSpanId,
+        name: opts.name,
+        kind: opts.kind ?? "internal",
+        status: closeOpts?.status ?? "ok",
+        startTime: new Date(startedAt).toISOString(),
+        endTime: new Date(endedAt).toISOString(),
+        durationMs: endedAt - startedAt,
+        attrs
+      });
+    }
+  };
+}
+__name(startSpan, "startSpan");
+
+// src/validate.ts
+var ID_RE = /^[A-Za-z0-9_.:\-]+$/;
+var MAX_ID_LEN = 256;
+function validateEndpoint(endpoint) {
+  if (typeof endpoint !== "string" || endpoint.length === 0) {
+    throw new Error("[InstantTasks] endpoint is required");
+  }
+  let url;
+  try {
+    url = new URL(endpoint);
+  } catch {
+    throw new Error(`[InstantTasks] endpoint must be a valid URL, got: ${endpoint.slice(0, 80)}`);
+  }
+  const isLocalhost = url.hostname === "localhost" || url.hostname === "127.0.0.1" || url.hostname === "::1" || url.hostname.endsWith(".localhost");
+  if (url.protocol === "http:" && !isLocalhost) {
+    throw new Error("[InstantTasks] endpoint must use https:// (http:// only allowed for localhost)");
+  }
+  if (url.protocol !== "http:" && url.protocol !== "https:") {
+    throw new Error(`[InstantTasks] endpoint protocol must be http(s), got: ${url.protocol}`);
+  }
+}
+__name(validateEndpoint, "validateEndpoint");
+function validateIdentifier(name, value) {
+  if (typeof value !== "string" || value.length === 0) {
+    throw new Error(`[InstantTasks] ${name} is required`);
+  }
+  if (value.length > MAX_ID_LEN) {
+    throw new Error(`[InstantTasks] ${name} exceeds ${MAX_ID_LEN} chars`);
+  }
+  if (!ID_RE.test(value)) {
+    throw new Error(`[InstantTasks] ${name} contains invalid characters`);
+  }
+}
+__name(validateIdentifier, "validateIdentifier");
+
+// src/client.ts
+var Client = class _Client {
+  static {
+    __name(this, "Client");
+  }
+  options;
+  listeners = /* @__PURE__ */ new Map();
+  spanExporter;
+  transportOpts;
+  constructor(opts) {
+    const endpoint = opts.endpoint ?? "https://tasks.koderlabs.net";
+    if (!opts.endpoint) warnDefaultEndpoint();
+    validateEndpoint(endpoint);
+    validateIdentifier("projectId", String(opts.projectId));
+    validateIdentifier("accessKey", String(opts.accessKey));
+    this.options = {
+      ...opts,
+      endpoint
+    };
+    this.transportOpts = {
+      fetch: this.options.fetch,
+      signingSecret: this.options.signingSecret
+    };
+    this.spanExporter = new SpanExporter(this.options.endpoint, this.options.projectId, this.options.accessKey, !!this.options.debug, this.transportOpts);
+    this.spanExporter.start();
+  }
+  /** Start a span. Caller MUST call .end() on the returned handle. */
+  startSpan(opts) {
+    return startSpan(this.spanExporter, opts);
+  }
+  /** Flush any buffered spans. Call on app shutdown. */
+  flushSpans() {
+    return this.spanExporter.flush();
+  }
+  /** Stop background timers (span exporter interval). Called by init() on replace. */
+  stop() {
+    this.spanExporter.stop();
+  }
+  /** Apply configured scrubber. Returns the event (possibly transformed). */
+  applyScrub(event) {
+    const scrub = this.options.scrub;
+    if (scrub === false) return event;
+    if (typeof scrub === "function") {
+      try {
+        return scrub(event);
+      } catch (err) {
+        internalError("custom scrub threw", err);
+        return event;
+      }
+    }
+    try {
+      return defaultScrubEvent(event);
+    } catch (err) {
+      internalError("default scrub threw", err);
+      return event;
+    }
+  }
+  async send(event, attachments) {
+    const debug = !!this.options.debug;
+    debugLog(debug, "send", event.kind);
+    let outgoing = this.applyScrub(event);
+    if (this.options.beforeSend) {
+      let threw = false;
+      try {
+        outgoing = await this.options.beforeSend(outgoing);
+      } catch (err) {
+        threw = true;
+        internalError("beforeSend threw \u2014 dropping event", err);
+        outgoing = null;
+      }
+      if (!outgoing) {
+        if (!threw) debugLog(debug, "event dropped by beforeSend");
+        const dropped = {
+          id: "dropped",
+          dropped: true
+        };
+        this.emit(threw ? "beforesend_error" : "send_dropped", {
+          event
+        });
+        return dropped;
+      }
+    }
+    if (this.options.dryRun) {
+      debugLog(debug, "dryRun \u2014 not sending", outgoing.kind);
+      const result = {
+        id: "dryrun",
+        dryRun: true
+      };
+      this.emit("send_dryrun", {
+        event: outgoing,
+        result
+      });
+      return result;
+    }
+    if (Date.now() < this.rateLimitedUntil) {
+      const result = {
+        id: "rate-limited",
+        dropped: true
+      };
+      this.emit("send_rate_limited", {
+        event: outgoing
+      });
+      return result;
+    }
+    try {
+      const result = await this.sendWithBackoff(outgoing, attachments, debug);
+      this.emit("send_success", {
+        event: outgoing,
+        result
+      });
+      return result;
+    } catch (err) {
+      this.emit("send_error", {
+        event: outgoing,
+        error: err
+      });
+      throw err;
+    }
+  }
+  rateLimitedUntil = 0;
+  static MAX_RETRIES = 2;
+  static BASE_BACKOFF_MS = 1e3;
+  async sendWithBackoff(event, attachments, debug) {
+    let attempt = 0;
+    let lastErr;
+    while (attempt <= _Client.MAX_RETRIES) {
+      try {
+        return await postEvent(this.options.endpoint, this.options.projectId, this.options.accessKey, event, attachments, this.transportOpts);
+      } catch (err) {
+        lastErr = err;
+        if (err instanceof PayloadTooLargeError) {
+          debugWarn(debug, err.message);
+          throw err;
+        }
+        if (err instanceof TransportHttpError) {
+          if (err.status === 429) {
+            const cooldown = parseRetryAfter(err.retryAfter) ?? 3e4;
+            this.rateLimitedUntil = Date.now() + cooldown;
+            throw err;
+          }
+          if (err.status < 500 || err.status >= 600) throw err;
+        }
+        attempt++;
+        if (attempt > _Client.MAX_RETRIES) break;
+        const wait = _Client.BASE_BACKOFF_MS * Math.pow(2, attempt - 1);
+        await new Promise((r) => setTimeout(r, wait));
+      }
+    }
+    throw lastErr;
+  }
+  on(event, listener) {
+    const arr = this.listeners.get(event) ?? [];
+    arr.push(listener);
+    this.listeners.set(event, arr);
+  }
+  emit(event, ...args) {
+    for (const l of this.listeners.get(event) ?? []) {
+      try {
+        l(...args);
+      } catch (e) {
+        internalError("listener threw", e);
+      }
+    }
+  }
+  setUser(user) {
+    this.options.user = user;
+  }
+  setCustomData(data) {
+    this.options.customData = {
+      ...this.options.customData,
+      ...data
+    };
+  }
+};
+var warnedDefaultEndpoint = false;
+function warnDefaultEndpoint() {
+  if (warnedDefaultEndpoint) return;
+  warnedDefaultEndpoint = true;
+  try {
+    const proc = globalThis.process;
+    if (proc?.env?.INSTANTTASKS_QUIET) return;
+  } catch {
+  }
+  internalError("init() called without an explicit `endpoint`. Defaulting to https://tasks.koderlabs.net is deprecated and will throw in the next major release. Set `endpoint: process.env.INSTANTTASKS_ENDPOINT` (or your self-hosted URL).");
+}
+__name(warnDefaultEndpoint, "warnDefaultEndpoint");
+function parseRetryAfter(header) {
+  if (!header) return null;
+  const sec = Number(header);
+  if (Number.isFinite(sec) && sec >= 0) return Math.min(sec * 1e3, 5 * 6e4);
+  const date = Date.parse(header);
+  if (Number.isFinite(date)) {
+    const ms = date - Date.now();
+    if (ms > 0) return Math.min(ms, 5 * 6e4);
+  }
+  return null;
+}
+__name(parseRetryAfter, "parseRetryAfter");
+
+// src/web-vitals.ts
+var RATING_THRESHOLDS = {
+  // [good, poor] — between = needs-improvement
+  LCP: [
+    2500,
+    4e3
+  ],
+  INP: [
+    200,
+    500
+  ],
+  CLS: [
+    0.1,
+    0.25
+  ],
+  FCP: [
+    1800,
+    3e3
+  ],
+  TTFB: [
+    800,
+    1800
+  ]
+};
+function rate(name, value) {
+  const [good, poor] = RATING_THRESHOLDS[name];
+  if (value <= good) return "good";
+  if (value >= poor) return "poor";
+  return "needs-improvement";
+}
+__name(rate, "rate");
+function randomHexShort() {
+  if (typeof crypto !== "undefined" && crypto.getRandomValues) {
+    const a = new Uint8Array(4);
+    crypto.getRandomValues(a);
+    return Array.from(a, (b) => b.toString(16).padStart(2, "0")).join("");
+  }
+  return Math.random().toString(36).slice(2, 10);
+}
+__name(randomHexShort, "randomHexShort");
+function buildReport(client, name, value) {
+  const env = client.options;
+  return client.send({
+    kind: "web_vital",
+    ts: (/* @__PURE__ */ new Date()).toISOString(),
+    release: env.release,
+    environment: env.environment,
+    user: env.user,
+    url: typeof location !== "undefined" ? location.href : "",
+    userAgent: typeof navigator !== "undefined" ? navigator.userAgent : "",
+    viewport: typeof window !== "undefined" ? {
+      width: window.innerWidth,
+      height: window.innerHeight
+    } : {
+      width: 0,
+      height: 0
+    },
+    metric: name,
+    value: Math.round(value * 1e3) / 1e3,
+    rating: rate(name, value),
+    measurementId: `${name}-${Date.now()}-${randomHexShort()}`,
+    navigationType: performance.getEntriesByType?.("navigation")?.[0]?.type
+  });
+}
+__name(buildReport, "buildReport");
+var MetricReporter = class MetricReporter2 {
+  static {
+    __name(this, "MetricReporter");
+  }
+  client;
+  name;
+  debounceMs;
+  reportOnHidden;
+  value = 0;
+  hasValue = false;
+  sent = false;
+  timer = null;
+  constructor(client, name, debounceMs, reportOnHidden) {
+    this.client = client;
+    this.name = name;
+    this.debounceMs = debounceMs;
+    this.reportOnHidden = reportOnHidden;
+  }
+  setValue(v) {
+    this.value = v;
+    this.hasValue = true;
+    if (this.reportOnHidden) return;
+    if (this.timer) clearTimeout(this.timer);
+    this.timer = setTimeout(() => this.flush(), this.debounceMs);
+  }
+  flush() {
+    if (this.sent || !this.hasValue) return;
+    this.sent = true;
+    if (this.timer) {
+      clearTimeout(this.timer);
+      this.timer = null;
+    }
+    void buildReport(this.client, this.name, this.value);
+  }
+};
+function captureWebVitals(client, opts = {}) {
+  if (typeof PerformanceObserver === "undefined") return;
+  const wanted = new Set(opts.metrics ?? [
+    "LCP",
+    "INP",
+    "CLS",
+    "FCP",
+    "TTFB"
+  ]);
+  const reportOnHidden = opts.reportOnHidden !== false;
+  const debounceMs = opts.debounceMs ?? 2e3;
+  const reporters = [];
+  const make = /* @__PURE__ */ __name((name) => {
+    const r = new MetricReporter(client, name, debounceMs, reportOnHidden);
+    reporters.push(r);
+    return r;
+  }, "make");
+  if (typeof document !== "undefined") {
+    const onHide = /* @__PURE__ */ __name(() => {
+      if (document.visibilityState === "hidden") {
+        for (const r of reporters) r.flush();
+      }
+    }, "onHide");
+    document.addEventListener("visibilitychange", onHide);
+  }
+  if (wanted.has("LCP")) {
+    safeObserve("largest-contentful-paint", (entries) => {
+      const r = lcp ?? (lcp = make("LCP"));
+      const last = entries[entries.length - 1];
+      if (last) r.setValue(last.startTime ?? 0);
+    });
+  }
+  let lcp = null;
+  if (wanted.has("FCP")) {
+    const r = make("FCP");
+    safeObserve("paint", (entries) => {
+      for (const e of entries) {
+        if (e.name === "first-contentful-paint") {
+          r.setValue(e.startTime ?? 0);
+        }
+      }
+    });
+  }
+  if (wanted.has("CLS")) {
+    const r = make("CLS");
+    let cls = 0;
+    safeObserve("layout-shift", (entries) => {
+      for (const e of entries) {
+        if (!e.hadRecentInput) cls += e.value;
+      }
+      r.setValue(cls);
+    });
+  }
+  if (wanted.has("INP")) {
+    const r = make("INP");
+    let maxInp = 0;
+    safeObserve("event", (entries) => {
+      for (const e of entries) {
+        if (e.duration > maxInp) maxInp = e.duration;
+      }
+      r.setValue(maxInp);
+    }, {
+      durationThreshold: 16
+    });
+  }
+  if (wanted.has("TTFB")) {
+    try {
+      const nav = performance.getEntriesByType?.("navigation")?.[0];
+      if (nav && typeof nav.responseStart === "number") {
+        const r = make("TTFB");
+        r.setValue(nav.responseStart);
+        r.flush();
+      }
+    } catch {
+    }
+  }
+}
+__name(captureWebVitals, "captureWebVitals");
+function safeObserve(type, cb, extra = {}) {
+  try {
+    const po = new PerformanceObserver((list) => cb(list.getEntries()));
+    po.observe({
+      type,
+      buffered: true,
+      ...extra
+    });
+  } catch {
+  }
+}
+__name(safeObserve, "safeObserve");
+
+// src/index.ts
+var currentClient = null;
+var currentIntegrations = [];
+function init(opts) {
+  if (currentClient) {
+    currentClient.emit("replaced");
+    try {
+      void currentClient.flushSpans?.();
+    } catch {
+    }
+    try {
+      currentClient.stop?.();
+    } catch {
+    }
+    for (const integration of currentIntegrations) {
+      try {
+        integration.teardown?.();
+      } catch (e) {
+        internalError(`integration ${integration.name} teardown failed`, e);
+      }
+    }
+    currentIntegrations = [];
+  }
+  const client = new Client(opts);
+  currentClient = client;
+  const integrations = opts.integrations ?? [];
+  for (const integration of integrations) integration.setup(client);
+  currentIntegrations = integrations;
+  return client;
+}
+__name(init, "init");
+function getClient() {
+  return currentClient;
+}
+__name(getClient, "getClient");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Client,
+  captureWebVitals,
+  defaultScrubEvent,
+  getClient,
+  init,
+  newSpanId,
+  newTraceId,
+  signRequest
+});
+//# sourceMappingURL=index.cjs.map