@devkitio/faultlens 0.1.5 → 1.0.1

package/dist/chunk-YQKZEUXA.js

@@ -0,0 +1,1282 @@
+// ../security/dist/redaction.js
+var REDACTED = "[\u5DF2\u8131\u654F]";
+var MAX_STRING_LENGTH = 32768;
+var SENSITIVE_KEY = /^(?:pass(?:word|wd)?|pwd|cookie|set[-_]?cookie|authorization|proxy[-_]?authorization|(?:access|refresh|id)?[-_]?token|api[-_]?key|secret|client[-_]?secret|private[-_]?key|card(?:number)?|pan|cvv|cvc|payment(?:data)?|oauth[-_]?(?:state|nonce)|state|nonce|registration[-_]?draft)$/i;
+var DANGEROUS_OBJECT_KEY = /^(?:__proto__|constructor|prototype)$/;
+var AUTH_VALUE = /^(?:Bearer|Basic|Digest)\s+\S+/i;
+var PRIVATE_KEY_VALUE = /-----BEGIN (?:RSA |EC |OPENSSH )?PRIVATE KEY-----/;
+var JWT_VALUE = /^eyJ[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+$/;
+var ABSOLUTE_HTTP_URL = /https?:\/\/[^\s<>"'`]+/gi;
+var SENSITIVE_PATH = /(\/(?:token|secret|password|key|reset|invite|download|verify|verification|activate|activation|credential)s?\/)([^/?#\s]+)/gi;
+var EMBEDDED_AUTH_VALUE = /\b((?:authorization|proxy[-_]?authorization)\s*[:=]\s*)?(?:Bearer|Basic|Digest)\s+[^\s,;"']+/gi;
+var EMBEDDED_SENSITIVE_VALUE = /\b((?:(?:access|refresh|id)[-_]?token|token|api[-_]?key|secret|client[-_]?secret|password|passwd|pwd)\s*[:=]\s*)[^\s,;"']+/gi;
+var EMBEDDED_JWT_VALUE = /\beyJ[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\b/g;
+function looksLikePaymentCard(value) {
+  const digits = value.replace(/[\s-]/g, "");
+  if (!/^\d{13,19}$/.test(digits))
+    return false;
+  let sum = 0;
+  let alternate = false;
+  for (let index = digits.length - 1; index >= 0; index -= 1) {
+    let digit = Number(digits[index]);
+    if (alternate) {
+      digit *= 2;
+      if (digit > 9)
+        digit -= 9;
+    }
+    sum += digit;
+    alternate = !alternate;
+  }
+  return sum % 10 === 0;
+}
+function redactHttpUrl(value) {
+  try {
+    const url = new URL(value);
+    const segments = url.pathname.split("/");
+    for (let index = 0; index < segments.length - 1; index += 1) {
+      if (/^(?:token|secret|password|key|reset|invite|download|verify|verification|activate|activation|credential)s?$/i.test(segments[index] ?? "")) {
+        segments[index + 1] = REDACTED;
+      }
+    }
+    return `${url.origin}${segments.join("/")}`;
+  } catch {
+    return REDACTED;
+  }
+}
+function redactSensitiveString(value) {
+  if (AUTH_VALUE.test(value) || PRIVATE_KEY_VALUE.test(value) || JWT_VALUE.test(value) || looksLikePaymentCard(value)) {
+    return REDACTED;
+  }
+  return value.slice(0, MAX_STRING_LENGTH).replace(ABSOLUTE_HTTP_URL, redactHttpUrl).replace(SENSITIVE_PATH, `$1${REDACTED}`).replace(EMBEDDED_AUTH_VALUE, (_matched, prefix) => `${prefix ?? ""}${REDACTED}`).replace(EMBEDDED_SENSITIVE_VALUE, `$1${REDACTED}`).replace(EMBEDDED_JWT_VALUE, REDACTED);
+}
+function shouldRedactObjectKey(key) {
+  return SENSITIVE_KEY.test(key) || DANGEROUS_OBJECT_KEY.test(key);
+}
+
+// src/sanitize.ts
+var REDACTED2 = "[\u5DF2\u8131\u654F]";
+function clientRedactString(value) {
+  return redactSensitiveString(value);
+}
+function clientRedact(value) {
+  const seen = /* @__PURE__ */ new WeakSet();
+  let keys = 0;
+  function visit(current, depth) {
+    if (typeof current === "string") {
+      return clientRedactString(current);
+    }
+    if (current === null || typeof current !== "object") return current;
+    if (depth > 10 || seen.has(current)) return "[\u5DF2\u622A\u65AD]";
+    seen.add(current);
+    if (Array.isArray(current)) return current.slice(0, 100).map((item) => visit(item, depth + 1));
+    const result = {};
+    for (const [key, item] of Object.entries(current)) {
+      keys += 1;
+      if (keys > 400) {
+        result.__truncated__ = "[\u5DF2\u622A\u65AD]";
+        break;
+      }
+      Object.defineProperty(result, key, {
+        value: shouldRedactObjectKey(key) ? REDACTED2 : visit(item, depth + 1),
+        enumerable: true,
+        configurable: true,
+        writable: true
+      });
+    }
+    return result;
+  }
+  return visit(value, 0);
+}
+
+// src/transport.ts
+function parseDirectDsn(dsn) {
+  const url = new URL(dsn);
+  const localHostname = ["localhost", "127.0.0.1", "[::1]"].includes(url.hostname);
+  if (url.protocol !== "https:" && !(url.protocol === "http:" && localHostname)) {
+    throw new Error("Direct DSN \u5FC5\u987B\u4F7F\u7528 HTTPS");
+  }
+  if (!url.username || url.password || url.pathname !== "/v1/direct/envelope" || url.search || url.hash) {
+    throw new Error("Direct DSN \u683C\u5F0F\u65E0\u6548");
+  }
+  const publicDsn = decodeURIComponent(url.username);
+  url.username = "";
+  url.password = "";
+  return { endpoint: url.toString(), publicDsn };
+}
+function parseRemoteSdkConfig(input) {
+  if (typeof input !== "object" || input === null) return void 0;
+  const value = input;
+  const telemetry = typeof value.telemetry === "object" && value.telemetry !== null ? {
+    ...typeof value.telemetry.enabled === "boolean" ? { enabled: value.telemetry.enabled } : {},
+    ...typeof value.telemetry.sampleRate === "number" ? { sampleRate: value.telemetry.sampleRate } : {},
+    ...typeof value.telemetry.dailyQuota === "number" ? { dailyQuota: value.telemetry.dailyQuota } : {},
+    ...typeof value.telemetry.retentionDays === "number" ? { retentionDays: value.telemetry.retentionDays } : {}
+  } : void 0;
+  return {
+    ...typeof value.enabled === "boolean" ? { enabled: value.enabled } : {},
+    ...typeof value.sampleRate === "number" ? { sampleRate: value.sampleRate } : {},
+    ...Array.isArray(value.errorTypeAllowlist) ? { errorTypeAllowlist: value.errorTypeAllowlist.filter((item) => typeof item === "string") } : {},
+    ...typeof value.queueLimit === "number" ? { queueLimit: value.queueLimit } : {},
+    ...typeof value.retryBaseMs === "number" ? { retryBaseMs: value.retryBaseMs } : {},
+    ...telemetry ? { telemetry } : {}
+  };
+}
+function retryAfterMs(response, body, now) {
+  const value = response.headers.get("retry-after");
+  if (value && /^\d+$/.test(value)) return Number(value) * 1e3;
+  if (value) {
+    const retryAt = Date.parse(value);
+    if (Number.isFinite(retryAt)) return Math.max(0, retryAt - now);
+  }
+  if (typeof body === "object" && body !== null && "retryAfterMs" in body && typeof body.retryAfterMs === "number") {
+    return Math.max(0, body.retryAfterMs);
+  }
+  return 0;
+}
+function responseCode(response, body) {
+  return typeof body === "object" && body !== null && "code" in body && typeof body.code === "string" ? body.code : `http_${response.status}`;
+}
+function parseBatchResults(envelope, body) {
+  if (typeof body !== "object" || body === null || !("ingestId" in body) || typeof body.ingestId !== "string" || !("results" in body) || !Array.isArray(body.results)) {
+    return void 0;
+  }
+  const expectedIds = new Set(envelope.events.map((event) => event.eventId));
+  const seenIds = /* @__PURE__ */ new Set();
+  const results = [];
+  for (const value of body.results) {
+    if (typeof value !== "object" || value === null) return void 0;
+    const eventId2 = value.eventId;
+    const status = value.status;
+    const code = value.code;
+    if (typeof eventId2 !== "string" || !expectedIds.has(eventId2) || seenIds.has(eventId2) || !["accepted", "duplicate", "rejected", "retryable"].includes(String(status)) || code !== void 0 && typeof code !== "string") {
+      return void 0;
+    }
+    seenIds.add(eventId2);
+    results.push({
+      eventId: eventId2,
+      status,
+      ...typeof code === "string" ? { errorCode: code } : {}
+    });
+  }
+  if (seenIds.size !== expectedIds.size) return void 0;
+  return {
+    ingestId: body.ingestId,
+    results
+  };
+}
+async function parseTransportResponse(response, envelope, now = Date.now()) {
+  let body;
+  try {
+    body = await response.json();
+  } catch {
+    body = void 0;
+  }
+  if (response.status === 202) {
+    const batch = parseBatchResults(envelope, body);
+    if (!batch) {
+      return {
+        kind: "retryable",
+        retryAfterMs: retryAfterMs(response, body, now),
+        code: "invalid_ingest_response"
+      };
+    }
+    return {
+      kind: "batch",
+      ...batch,
+      retryAfterMs: retryAfterMs(response, body, now)
+    };
+  }
+  if (response.status === 429 || response.status >= 500) {
+    return {
+      kind: "retryable",
+      retryAfterMs: retryAfterMs(response, body, now),
+      code: responseCode(response, body)
+    };
+  }
+  return { kind: "permanent_error", code: responseCode(response, body) };
+}
+var FetchTransport = class {
+  constructor(ingest, fetcher = fetch, now = Date.now) {
+    this.ingest = ingest;
+    this.fetcher = fetcher;
+    this.now = now;
+  }
+  async send(envelope) {
+    try {
+      const direct = this.ingest.mode === "direct" ? parseDirectDsn(this.ingest.dsn) : void 0;
+      const endpoint = direct?.endpoint ?? this.ingest.endpoint;
+      const response = await this.fetcher(endpoint, {
+        method: "POST",
+        headers: {
+          "content-type": "application/json",
+          ...direct ? { "x-faultlens-dsn": direct.publicDsn } : {}
+        },
+        body: JSON.stringify(envelope),
+        credentials: "omit",
+        cache: "no-store",
+        redirect: "error",
+        keepalive: true
+      });
+      return await parseTransportResponse(response, envelope, this.now());
+    } catch {
+      return { kind: "network_error", code: "network_error" };
+    }
+  }
+  async loadRemoteConfig() {
+    const result = await this.loadRemoteConfigResult();
+    return result.kind === "configured" ? result.config : void 0;
+  }
+  async loadRemoteConfigResult() {
+    try {
+      const direct = this.ingest.mode === "direct" ? parseDirectDsn(this.ingest.dsn) : void 0;
+      const base = direct?.endpoint ?? this.ingest.endpoint;
+      const endpoint = `${base.replace(/\/$/, "")}/config`;
+      const response = await this.fetcher(endpoint, {
+        method: "GET",
+        headers: direct ? { "x-faultlens-dsn": direct.publicDsn } : {},
+        credentials: "omit",
+        cache: "no-store",
+        redirect: "error"
+      });
+      if (response.status === 404) return { kind: "unsupported", code: "config_not_found" };
+      if (response.status === 422) return { kind: "unsupported", code: "unsupported_protocol" };
+      if (!response.ok) return { kind: "retryable_error", code: `http_${response.status}` };
+      let body;
+      try {
+        body = await response.json();
+      } catch {
+        return { kind: "retryable_error", code: "invalid_remote_config" };
+      }
+      const config = parseRemoteSdkConfig(body);
+      return config ? { kind: "configured", config } : { kind: "retryable_error", code: "invalid_remote_config" };
+    } catch {
+      return { kind: "retryable_error", code: "network_error" };
+    }
+  }
+};
+
+// src/telemetry-transport.ts
+function responseCode2(response, body) {
+  return typeof body === "object" && body !== null && "code" in body && typeof body.code === "string" ? body.code : `http_${response.status}`;
+}
+function retryAfterMs2(response, body, now) {
+  const value = response.headers.get("retry-after");
+  if (value && /^\d+$/.test(value)) return Number(value) * 1e3;
+  if (value) {
+    const retryAt = Date.parse(value);
+    if (Number.isFinite(retryAt)) return Math.max(0, retryAt - now);
+  }
+  if (typeof body === "object" && body !== null && "retryAfterMs" in body && typeof body.retryAfterMs === "number") {
+    return Math.max(0, body.retryAfterMs);
+  }
+  return 0;
+}
+function parseBatchResults2(envelope, body) {
+  if (typeof body !== "object" || body === null || typeof body.ingestId !== "string" || !Array.isArray(body.results)) {
+    return void 0;
+  }
+  const expectedIds = /* @__PURE__ */ new Set([
+    ...envelope.traces.map((item) => item.telemetryId),
+    ...envelope.spans.map((item) => item.telemetryId),
+    ...envelope.webVitals.map((item) => item.telemetryId)
+  ]);
+  const seenIds = /* @__PURE__ */ new Set();
+  const results = [];
+  for (const value of body.results) {
+    if (typeof value !== "object" || value === null) return void 0;
+    const telemetryId = value.telemetryId;
+    const status = value.status;
+    const code = value.code;
+    if (typeof telemetryId !== "string" || !expectedIds.has(telemetryId) || seenIds.has(telemetryId) || !["accepted", "duplicate", "rejected", "retryable"].includes(String(status)) || code !== void 0 && typeof code !== "string") {
+      return void 0;
+    }
+    seenIds.add(telemetryId);
+    results.push({
+      telemetryId,
+      status,
+      ...typeof code === "string" ? { errorCode: code } : {}
+    });
+  }
+  if (seenIds.size !== expectedIds.size) return void 0;
+  return { ingestId: body.ingestId, results };
+}
+function relayTelemetryEndpoint(endpoint) {
+  if (!/\/envelope\/?$/.test(endpoint)) {
+    throw new Error("Relay Endpoint \u5FC5\u987B\u4EE5 /envelope \u7ED3\u5C3E");
+  }
+  return endpoint.replace(/\/envelope\/?$/, "/telemetry");
+}
+var FetchTelemetryTransport = class {
+  constructor(ingest, fetcher = fetch, now = Date.now) {
+    this.ingest = ingest;
+    this.fetcher = fetcher;
+    this.now = now;
+  }
+  async send(envelope) {
+    try {
+      const direct = this.ingest.mode === "direct" ? parseDirectDsn(this.ingest.dsn) : void 0;
+      const endpoint = direct ? direct.endpoint.replace(/\/v1\/direct\/envelope$/, "/v1/direct/telemetry") : relayTelemetryEndpoint(this.ingest.endpoint);
+      const response = await this.fetcher(endpoint, {
+        method: "POST",
+        headers: {
+          "content-type": "application/json",
+          ...direct ? { "x-faultlens-dsn": direct.publicDsn } : {}
+        },
+        body: JSON.stringify(envelope),
+        credentials: "omit",
+        cache: "no-store",
+        redirect: "error",
+        keepalive: true
+      });
+      return await parseTelemetryTransportResponse(response, envelope, this.now());
+    } catch {
+      return { kind: "network_error", code: "network_error" };
+    }
+  }
+};
+async function parseTelemetryTransportResponse(response, envelope, now = Date.now()) {
+  let body;
+  try {
+    body = await response.json();
+  } catch {
+    body = void 0;
+  }
+  if (response.status === 404 || response.status === 422) {
+    return { kind: "unsupported", code: responseCode2(response, body) };
+  }
+  if (response.status === 202) {
+    const batch = parseBatchResults2(envelope, body);
+    if (!batch) {
+      return {
+        kind: "retryable",
+        retryAfterMs: retryAfterMs2(response, body, now),
+        code: "invalid_telemetry_response"
+      };
+    }
+    return {
+      kind: "batch",
+      ...batch,
+      retryAfterMs: retryAfterMs2(response, body, now)
+    };
+  }
+  if (response.status === 429 || response.status >= 500) {
+    return {
+      kind: "retryable",
+      retryAfterMs: retryAfterMs2(response, body, now),
+      code: responseCode2(response, body)
+    };
+  }
+  return { kind: "permanent_error", code: responseCode2(response, body) };
+}
+
+// src/trace-context.ts
+var TRACE_PARENT_PATTERN = /^([0-9a-f]{2})-([0-9a-f]{32})-([0-9a-f]{16})-([0-9a-f]{2})(?:-(.+))?$/;
+function validTraceId(value) {
+  return /^[0-9a-f]{32}$/.test(value) && value !== "0".repeat(32);
+}
+function validSpanId(value) {
+  return /^[0-9a-f]{16}$/.test(value) && value !== "0".repeat(16);
+}
+function validTraceState(value) {
+  return value !== void 0 && value.length > 0 && value.length <= 512 && !/[\r\n]/.test(value);
+}
+function parseTraceParent(traceParent, traceState) {
+  if (!traceParent) return void 0;
+  const match = traceParent.match(TRACE_PARENT_PATTERN);
+  if (!match) return void 0;
+  const [, version, traceId, spanId, traceFlags, extension] = match;
+  if (!version || version === "ff" || !traceId || !spanId || !traceFlags || !validTraceId(traceId) || !validSpanId(spanId) || version === "00" && extension !== void 0) {
+    return void 0;
+  }
+  return {
+    traceId,
+    spanId,
+    traceFlags,
+    ...validTraceState(traceState ?? void 0) ? { traceState } : {},
+    ...version === "00" ? {} : { traceVersion: version }
+  };
+}
+function formatTraceParent(context) {
+  const version = context.traceVersion ?? "00";
+  if (!/^[0-9a-f]{2}$/.test(version) || version === "ff" || !validTraceId(context.traceId) || !validSpanId(context.spanId) || !/^[0-9a-f]{2}$/.test(context.traceFlags)) {
+    throw new Error("Trace Context \u65E0\u6548");
+  }
+  return `${version}-${context.traceId}-${context.spanId}-${context.traceFlags}`;
+}
+function traceContextHeaders(context) {
+  return {
+    traceparent: formatTraceParent(context),
+    ...validTraceState(context.traceState) ? { tracestate: context.traceState } : {}
+  };
+}
+
+// src/monitor.ts
+var SDK_VERSION = "1.0.1";
+var PROTOCOL_VERSION = "1.0";
+var REVOKED_CREDENTIAL_CODES = /* @__PURE__ */ new Set(["invalid_dsn", "relay_key_revoked", "credential_revoked"]);
+function eventId() {
+  if (typeof crypto !== "undefined" && "randomUUID" in crypto) return crypto.randomUUID();
+  return `${Date.now().toString(36)}-${Math.random().toString(36).slice(2)}-${Math.random().toString(36).slice(2)}`;
+}
+function randomHexId(byteLength) {
+  let value = "";
+  do {
+    if (typeof crypto !== "undefined" && "getRandomValues" in crypto) {
+      const bytes = crypto.getRandomValues(new Uint8Array(byteLength));
+      value = Array.from(bytes, (item) => item.toString(16).padStart(2, "0")).join("");
+    } else {
+      value = Array.from(
+        { length: byteLength * 2 },
+        () => Math.floor(Math.random() * 16).toString(16)
+      ).join("");
+    }
+  } while (/^0+$/.test(value));
+  return value;
+}
+function validTraceId2(value) {
+  return !!value && /^[0-9a-f]{32}$/.test(value) && value !== "0".repeat(32);
+}
+function validSpanId2(value) {
+  return !!value && /^[0-9a-f]{16}$/.test(value) && value !== "0".repeat(16);
+}
+function normalizedFilename(filename) {
+  try {
+    const url = new URL(filename);
+    url.search = "";
+    url.hash = "";
+    return url.toString();
+  } catch {
+    return filename.split(/[?#]/, 1)[0] ?? filename;
+  }
+}
+function rawStackFrames(stack) {
+  return stack.split("\n").slice(1, 101).map((line) => {
+    const trimmed = line.trim();
+    const match = trimmed.match(/(?:at\s+(.+?)\s+\()?(.+?):(\d+):(\d+)\)?$/);
+    return {
+      filename: match?.[2] ?? trimmed.slice(0, 2048),
+      ...match?.[1] ? { function: match[1].slice(0, 1024) } : {},
+      ...match?.[3] ? { line: Number(match[3]) } : {},
+      ...match?.[4] ? { column: Number(match[4]) } : {},
+      inApp: match?.[2] ? !/node_modules|<anonymous>/.test(match[2]) : false
+    };
+  });
+}
+function runtimeDebugIds() {
+  const value = globalThis.__FAULTLENS_DEBUG_IDS__;
+  const result = /* @__PURE__ */ new Map();
+  if (!value || typeof value !== "object") return result;
+  for (const [stack, debugId] of Object.entries(value)) {
+    if (typeof debugId !== "string") continue;
+    const frame = rawStackFrames(stack).find((item) => item.filename);
+    if (frame) result.set(normalizedFilename(frame.filename), debugId);
+  }
+  return result;
+}
+function parseErrorStack(error) {
+  let stack = "";
+  try {
+    stack = typeof error.stack === "string" ? error.stack : "";
+  } catch {
+    return [];
+  }
+  const debugIds = runtimeDebugIds();
+  return stack ? rawStackFrames(stack).map((frame) => {
+    const debugId = debugIds.get(normalizedFilename(frame.filename));
+    return debugId ? { ...frame, debugId } : frame;
+  }) : [];
+}
+function errorShape(error) {
+  let isError = false;
+  try {
+    isError = error instanceof Error;
+  } catch {
+    isError = false;
+  }
+  if (isError) {
+    let name = "Error";
+    let message = "\u65E0\u6CD5\u5B89\u5168\u8BFB\u53D6\u5F02\u5E38\u5185\u5BB9";
+    try {
+      if (typeof error.name === "string" && error.name) {
+        name = error.name;
+      }
+    } catch {
+      name = "Error";
+    }
+    try {
+      if (typeof error.message === "string") {
+        message = clientRedactString(error.message);
+      }
+    } catch {
+      message = "\u65E0\u6CD5\u5B89\u5168\u8BFB\u53D6\u5F02\u5E38\u5185\u5BB9";
+    }
+    return {
+      type: name,
+      message,
+      stack: parseErrorStack(error)
+    };
+  }
+  if (typeof error === "string") return { type: "Error", message: clientRedactString(error), stack: [] };
+  return {
+    type: "NonErrorException",
+    message: "\u6355\u83B7\u5230\u975E Error \u7C7B\u578B\u5F02\u5E38",
+    stack: []
+  };
+}
+function shallowFingerprint(event) {
+  const frame = event.stack.find((item) => item.inApp) ?? event.stack[0];
+  return `${event.type}${event.message}${frame?.filename ?? ""}${frame?.line ?? ""}`;
+}
+function createMonitorRuntime(options, overrides = {}) {
+  const dependencies = {
+    transport: overrides.transport ?? new FetchTransport(options.ingest),
+    telemetryTransport: overrides.telemetryTransport ?? new FetchTelemetryTransport(options.ingest),
+    now: overrides.now ?? (() => /* @__PURE__ */ new Date()),
+    random: overrides.random ?? Math.random,
+    createEventId: overrides.createEventId ?? eventId,
+    createTraceId: overrides.createTraceId ?? (() => randomHexId(16)),
+    createSpanId: overrides.createSpanId ?? (() => randomHexId(8))
+  };
+  let queue = [];
+  const pending = /* @__PURE__ */ new Set();
+  const pendingEventIds = /* @__PURE__ */ new Set();
+  const breadcrumbs = [];
+  const namedContext = /* @__PURE__ */ new Map();
+  const seenErrors = /* @__PURE__ */ new WeakSet();
+  const recentFingerprints = /* @__PURE__ */ new Map();
+  const droppedReasons = {};
+  const localQueueLimit = Math.min(50, Math.max(1, options.queueLimit ?? 50));
+  const localSampleRate = Math.min(1, Math.max(0, options.sampleRate ?? 1));
+  const localTelemetrySampleRate = Math.min(1, Math.max(0, options.telemetry?.sampleRate ?? 1));
+  const remoteConfigRefreshIntervalMs = Math.min(
+    60 * 60 * 1e3,
+    Math.max(3e4, options.remoteConfigRefreshIntervalMs ?? 5 * 60 * 1e3)
+  );
+  let queueLimit = localQueueLimit;
+  let sampleRate = localSampleRate;
+  let errorTypeAllowlist;
+  let user = null;
+  let closed = false;
+  let sendTimer;
+  let remoteConfigTimer;
+  let sendTimerDueAt;
+  let activeFlush;
+  let recentSendStatus = "idle";
+  let lastRateLimitedAt = null;
+  let remotelyDisabled = false;
+  let retryBaseMs = 250;
+  let telemetryEnabled = false;
+  let telemetryUnsupported = false;
+  let remoteConfigLastRefreshAt = null;
+  let remoteConfigLastSuccessAt = null;
+  let remoteConfigFailureCode = null;
+  let remoteConfigRefreshFailures = 0;
+  let telemetrySampleRate = localTelemetrySampleRate;
+  const telemetryRequested = options.telemetry?.enabled !== false;
+  let telemetryQueue = [];
+  const telemetrySamplingDecisions = /* @__PURE__ */ new Map();
+  let activeSpan;
+  const spanContextManager = overrides.spanContextManager ?? {
+    active: () => activeSpan,
+    run(span, callback) {
+      const previous = activeSpan;
+      activeSpan = span;
+      try {
+        return callback();
+      } finally {
+        activeSpan = previous;
+      }
+    }
+  };
+  const persistentQueue = overrides.persistentQueue;
+  const sendLease = overrides.sendLease;
+  const restorePromise = persistentQueue?.load(dependencies.now().getTime()).then((items) => {
+    for (const item of items) {
+      if (!queue.some((queued) => queued.event.eventId === item.id)) {
+        queue.push(item);
+      }
+    }
+    scheduleNextQueuedFlush();
+  }).catch(() => drop("persistent_queue_unavailable"));
+  const legacyRemoteConfigLoader = dependencies.transport.loadRemoteConfig?.bind(
+    dependencies.transport
+  );
+  const resultRemoteConfigLoader = dependencies.transport.loadRemoteConfigResult?.bind(
+    dependencies.transport
+  );
+  const loadRemoteConfigResult = resultRemoteConfigLoader ? resultRemoteConfigLoader : legacyRemoteConfigLoader ? async () => {
+    try {
+      const config = await legacyRemoteConfigLoader();
+      return config ? { kind: "configured", config } : { kind: "retryable_error", code: "remote_config_unavailable" };
+    } catch {
+      return { kind: "retryable_error", code: "network_error" };
+    }
+  } : void 0;
+  function applyRemoteConfig(config) {
+    remotelyDisabled = config.enabled === false;
+    sampleRate = typeof config.sampleRate === "number" ? Math.min(localSampleRate, Math.max(0, Math.min(1, config.sampleRate))) : localSampleRate;
+    queueLimit = typeof config.queueLimit === "number" ? Math.min(localQueueLimit, Math.max(1, config.queueLimit)) : localQueueLimit;
+    retryBaseMs = typeof config.retryBaseMs === "number" ? Math.min(3e4, Math.max(1, config.retryBaseMs)) : 250;
+    errorTypeAllowlist = config.errorTypeAllowlist ? new Set(config.errorTypeAllowlist) : void 0;
+    telemetryEnabled = telemetryRequested && config.telemetry?.enabled === true;
+    telemetryUnsupported = false;
+    telemetrySampleRate = typeof config.telemetry?.sampleRate === "number" ? Math.min(localTelemetrySampleRate, Math.max(0, Math.min(1, config.telemetry.sampleRate))) : localTelemetrySampleRate;
+  }
+  function scheduleRemoteConfigRefresh() {
+    if (!loadRemoteConfigResult || closed) return;
+    remoteConfigTimer = setTimeout(() => {
+      remoteConfigTimer = void 0;
+      void refreshRemoteConfig();
+    }, remoteConfigRefreshIntervalMs);
+    remoteConfigTimer.unref?.();
+  }
+  async function refreshRemoteConfig() {
+    if (!loadRemoteConfigResult || closed) return;
+    try {
+      const result = await loadRemoteConfigResult();
+      if (closed) return;
+      remoteConfigLastRefreshAt = dependencies.now().toISOString();
+      if (result.kind === "configured") {
+        applyRemoteConfig(result.config);
+        remoteConfigLastSuccessAt = remoteConfigLastRefreshAt;
+        remoteConfigFailureCode = null;
+        return;
+      }
+      remoteConfigFailureCode = result.code;
+      remoteConfigRefreshFailures += 1;
+      if (result.kind === "unsupported") {
+        telemetryEnabled = false;
+        telemetryUnsupported = true;
+        drop(`remote_config_${result.code}`);
+      }
+    } catch {
+      if (!closed) {
+        remoteConfigLastRefreshAt = dependencies.now().toISOString();
+        remoteConfigFailureCode = "network_error";
+        remoteConfigRefreshFailures += 1;
+      }
+    } finally {
+      scheduleRemoteConfigRefresh();
+    }
+  }
+  const remoteConfigPromise = refreshRemoteConfig();
+  function drop(reason) {
+    droppedReasons[reason] = (droppedReasons[reason] ?? 0) + 1;
+  }
+  function scheduleFlush(delayMs = 100) {
+    if (closed) return;
+    const normalizedDelay = Math.max(0, delayMs);
+    const dueAt = dependencies.now().getTime() + normalizedDelay;
+    if (sendTimer && sendTimerDueAt !== void 0 && sendTimerDueAt <= dueAt) return;
+    if (sendTimer) clearTimeout(sendTimer);
+    sendTimerDueAt = dueAt;
+    sendTimer = setTimeout(() => {
+      sendTimer = void 0;
+      sendTimerDueAt = void 0;
+      void flushInternal();
+    }, normalizedDelay);
+  }
+  function scheduleNextQueuedFlush() {
+    if (queue.length === 0 || closed) return;
+    const now = dependencies.now().getTime();
+    const nextAttemptAt = Math.min(...queue.map((item) => item.nextAttemptAt));
+    scheduleFlush(Math.max(0, nextAttemptAt - now));
+  }
+  function retryDelay(item, serverDelayMs = 0) {
+    const exponent = Math.min(16, item.attemptCount);
+    const jitteredBackoff = retryBaseMs * 2 ** exponent * (0.5 + dependencies.random() * 0.5);
+    return Math.min(
+      24 * 60 * 60 * 1e3,
+      Math.max(serverDelayMs, Math.min(3e4, Math.round(jitteredBackoff)))
+    );
+  }
+  function retryItem(item, retryAfterMs3, errorCode) {
+    const attemptCount = item.attemptCount + 1;
+    const next = {
+      ...item,
+      attemptCount,
+      nextAttemptAt: dependencies.now().getTime() + retryDelay({ ...item, attemptCount }, retryAfterMs3),
+      lastErrorCode: errorCode
+    };
+    return next;
+  }
+  async function persistRetriedItems(items) {
+    if (!persistentQueue) return;
+    await Promise.all(
+      items.map(
+        (item) => persistentQueue.put(item).catch(() => drop("persistent_queue_write_failed"))
+      )
+    );
+  }
+  async function prepare(event) {
+    try {
+      const beforeSendResult = options.beforeSend ? await options.beforeSend(event) : event;
+      if (!beforeSendResult) {
+        drop("before_send");
+        return;
+      }
+      const sanitized = clientRedact(beforeSendResult);
+      const size = new TextEncoder().encode(JSON.stringify(sanitized)).byteLength;
+      if (size > 128 * 1024) {
+        drop("payload_too_large");
+        return;
+      }
+      while (queue.length >= queueLimit) {
+        const removed = queue.shift();
+        if (removed) await persistentQueue?.remove([removed.id]).catch(() => void 0);
+        drop("queue_limit");
+      }
+      const enqueuedAt = dependencies.now().getTime();
+      const item = {
+        id: sanitized.eventId,
+        event: sanitized,
+        enqueuedAt,
+        bytes: size,
+        protocolVersion: PROTOCOL_VERSION,
+        attemptCount: 0,
+        nextAttemptAt: enqueuedAt
+      };
+      queue.push(item);
+      await persistentQueue?.put(item).catch(() => drop("persistent_queue_write_failed"));
+      scheduleFlush();
+    } catch {
+      drop("before_send_error");
+    }
+  }
+  function enqueue(event) {
+    pendingEventIds.add(event.eventId);
+    const promise = prepare(event).finally(() => {
+      pending.delete(promise);
+      pendingEventIds.delete(event.eventId);
+    });
+    pending.add(promise);
+    return event.eventId;
+  }
+  function baseEvent(shape, capture = {}) {
+    const context = {
+      ...user ? { user } : {},
+      contexts: Object.fromEntries(namedContext),
+      breadcrumbs: breadcrumbs.slice(-50),
+      ...capture.context === void 0 ? {} : { captured: capture.context },
+      contextMode: options.contextMode ?? "minimal"
+    };
+    const activeTrace = spanContextManager.active()?.getTraceContext();
+    const traceId = validTraceId2(capture.traceId) ? capture.traceId : activeTrace?.traceId;
+    const spanId = validSpanId2(capture.spanId) ? capture.spanId : activeTrace?.spanId;
+    return {
+      eventId: dependencies.createEventId(),
+      occurredAt: dependencies.now().toISOString(),
+      type: shape.type,
+      message: shape.message,
+      handled: capture.handled ?? false,
+      mechanism: capture.mechanism ?? "manual",
+      level: capture.level ?? "error",
+      stack: shape.stack,
+      tags: clientRedact(capture.tags ?? {}),
+      context: clientRedact(context),
+      ...traceId ? { traceId } : {},
+      ...spanId ? { spanId } : {}
+    };
+  }
+  function normalizedAttributeValue(value) {
+    if (typeof value === "number" && !Number.isFinite(value)) return void 0;
+    return typeof value === "string" ? clientRedactString(value).slice(0, 4096) : value;
+  }
+  function queueFinishedSpan(span) {
+    if (closed || !telemetryRequested) return;
+    const occurredAt = span.endedAt.toISOString();
+    const base = {
+      occurredAt,
+      traceId: span.traceId,
+      name: span.name,
+      startedAt: span.startedAt.toISOString(),
+      endedAt: occurredAt,
+      status: span.status,
+      attributes: clientRedact(span.attributes)
+    };
+    const now = dependencies.now().getTime();
+    if (!span.parentSpanId) {
+      telemetryQueue.push({
+        kind: "trace",
+        item: { telemetryId: dependencies.createEventId(), ...base },
+        attemptCount: 0,
+        nextAttemptAt: now
+      });
+    }
+    telemetryQueue.push({
+      kind: "span",
+      item: {
+        telemetryId: dependencies.createEventId(),
+        ...base,
+        spanId: span.spanId,
+        ...span.parentSpanId ? { parentSpanId: span.parentSpanId } : {}
+      },
+      attemptCount: 0,
+      nextAttemptAt: now
+    });
+    scheduleFlush();
+  }
+  function startSpan(name, spanOptions = {}) {
+    const parent = spanOptions.parent ?? spanContextManager.active()?.getTraceContext();
+    const traceId = validTraceId2(parent?.traceId) ? parent.traceId : dependencies.createTraceId();
+    const spanId = dependencies.createSpanId();
+    const parentSpanId = validSpanId2(parent?.spanId) ? parent.spanId : void 0;
+    const traceFlags = /^[0-9a-f]{2}$/.test(parent?.traceFlags ?? "") ? parent.traceFlags : telemetrySampleRate > 0 ? "01" : "00";
+    const startedAt = spanOptions.startTime && !Number.isNaN(spanOptions.startTime.getTime()) ? new Date(spanOptions.startTime) : dependencies.now();
+    const attributes = {};
+    for (const [key, value] of Object.entries(spanOptions.attributes ?? {})) {
+      const normalized = normalizedAttributeValue(value);
+      if (normalized !== void 0) attributes[key.slice(0, 256)] = normalized;
+    }
+    let status = "unset";
+    let ended = false;
+    const normalizedName = name.trim().slice(0, 1024) || "\u672A\u547D\u540D Span";
+    const traceContext = () => ({
+      traceId,
+      spanId,
+      traceFlags,
+      ...parent?.traceState ? { traceState: parent.traceState } : {}
+    });
+    return {
+      traceId,
+      spanId,
+      ...parentSpanId ? { parentSpanId } : {},
+      name: normalizedName,
+      setAttribute(key, value) {
+        if (ended) return;
+        const normalized = normalizedAttributeValue(value);
+        if (normalized !== void 0) attributes[key.slice(0, 256)] = normalized;
+      },
+      setStatus(value) {
+        if (!ended) status = value;
+      },
+      getTraceContext() {
+        return traceContext();
+      },
+      toTraceHeaders() {
+        return traceContextHeaders(traceContext());
+      },
+      end(value) {
+        if (ended) return;
+        if (value) status = value;
+        ended = true;
+        queueFinishedSpan({
+          traceId,
+          spanId,
+          ...parentSpanId ? { parentSpanId } : {},
+          name: normalizedName,
+          startedAt,
+          endedAt: dependencies.now(),
+          status,
+          attributes: { ...attributes }
+        });
+      }
+    };
+  }
+  function captureWebVital(vital) {
+    const telemetryId = dependencies.createEventId();
+    const names = /* @__PURE__ */ new Set(["CLS", "FCP", "FID", "INP", "LCP", "TTFB"]);
+    const ratings = /* @__PURE__ */ new Set(["good", "needs-improvement", "poor"]);
+    const occurredAt = vital.occurredAt instanceof Date ? new Date(vital.occurredAt) : new Date(vital.occurredAt ?? dependencies.now());
+    let pageUrl;
+    try {
+      pageUrl = new URL(vital.pageUrl);
+      if (pageUrl.protocol !== "http:" && pageUrl.protocol !== "https:") pageUrl = void 0;
+    } catch {
+      pageUrl = void 0;
+    }
+    if (closed || !telemetryRequested || !names.has(vital.name) || !ratings.has(vital.rating) || !Number.isFinite(vital.value) || vital.value < 0 || Number.isNaN(occurredAt.getTime()) || !pageUrl) {
+      drop(closed ? "closed" : "invalid_web_vital");
+      return telemetryId;
+    }
+    pageUrl.search = "";
+    pageUrl.hash = "";
+    const attributes = {};
+    for (const [key, value] of Object.entries(vital.attributes ?? {})) {
+      const normalized = normalizedAttributeValue(value);
+      if (normalized !== void 0) attributes[key.slice(0, 256)] = normalized;
+    }
+    telemetryQueue.push({
+      kind: "web_vital",
+      item: {
+        telemetryId,
+        occurredAt: occurredAt.toISOString(),
+        name: vital.name,
+        value: vital.value,
+        rating: vital.rating,
+        pageUrl: pageUrl.toString(),
+        ...vital.navigationType ? { navigationType: clientRedactString(vital.navigationType).slice(0, 128) } : {},
+        attributes: clientRedact(attributes)
+      },
+      attemptCount: 0,
+      nextAttemptAt: dependencies.now().getTime()
+    });
+    scheduleFlush();
+    return telemetryId;
+  }
+  function shouldIgnore(error, event) {
+    if (closed || remotelyDisabled) {
+      drop(closed ? "closed" : "remote_disabled");
+      return true;
+    }
+    if (options.ignoreError?.(error)) {
+      drop("ignored");
+      return true;
+    }
+    if (errorTypeAllowlist && !errorTypeAllowlist.has(event.type)) {
+      drop("remote_type_filter");
+      return true;
+    }
+    if (typeof error === "object" && error !== null) {
+      if (seenErrors.has(error)) {
+        drop("duplicate");
+        return true;
+      }
+      seenErrors.add(error);
+    }
+    const fingerprint = shallowFingerprint(event);
+    const seenAt = recentFingerprints.get(fingerprint);
+    const now = dependencies.now().getTime();
+    if (seenAt !== void 0 && now - seenAt < 2e3) {
+      drop("duplicate");
+      return true;
+    }
+    recentFingerprints.set(fingerprint, now);
+    if (dependencies.random() >= sampleRate) {
+      drop("sampled");
+      return true;
+    }
+    return false;
+  }
+  function envelope(events) {
+    return {
+      protocolVersion: PROTOCOL_VERSION,
+      sdkName: "@devkitio/faultlens",
+      sdkVersion: SDK_VERSION,
+      clientType: options.ingest.mode === "relay" ? "relay" : "browser",
+      expectedEnvironment: options.expectedEnvironment,
+      release: options.release,
+      dist: options.dist ?? "default",
+      buildId: options.buildId ?? options.release,
+      clientBatchId: dependencies.createEventId(),
+      events
+    };
+  }
+  async function performEventFlush() {
+    await restorePromise;
+    await Promise.all([...pending]);
+    const now = dependencies.now().getTime();
+    const expiredBefore = now - 24 * 60 * 60 * 1e3;
+    const expiredIds = queue.filter((item) => item.enqueuedAt < expiredBefore).map((item) => item.id);
+    if (expiredIds.length > 0) {
+      const expired = new Set(expiredIds);
+      queue = queue.filter((item) => !expired.has(item.id));
+      await persistentQueue?.remove(expiredIds).catch(() => void 0);
+      drop("queue_expired");
+    }
+    if (queue.length === 0) return true;
+    const batch = queue.filter((item) => item.nextAttemptAt <= now).slice(0, 20);
+    if (batch.length === 0) {
+      scheduleNextQueuedFlush();
+      return false;
+    }
+    if (sendLease && !sendLease.acquire(now)) {
+      scheduleFlush(250);
+      return false;
+    }
+    recentSendStatus = "sending";
+    let outcome;
+    try {
+      outcome = await dependencies.transport.send(envelope(batch.map((item) => item.event)));
+    } catch {
+      outcome = { kind: "network_error", code: "network_error" };
+    } finally {
+      sendLease?.release();
+    }
+    if (outcome.kind === "batch") {
+      const expectedIds = new Set(batch.map((item) => item.id));
+      const seenIds = /* @__PURE__ */ new Set();
+      const validResults = outcome.results.every((result) => {
+        if (!expectedIds.has(result.eventId) || seenIds.has(result.eventId)) return false;
+        seenIds.add(result.eventId);
+        return true;
+      }) && seenIds.size === expectedIds.size;
+      if (!validResults) {
+        queue = queue.map(
+          (item) => expectedIds.has(item.id) ? retryItem(item, outcome.retryAfterMs, "invalid_ingest_response") : item
+        );
+        await persistRetriedItems(queue.filter((item) => expectedIds.has(item.id)));
+        recentSendStatus = "retryable";
+        scheduleNextQueuedFlush();
+        return false;
+      }
+      const byId = new Map(outcome.results.map((result) => [result.eventId, result]));
+      const removedIds = [];
+      let hasRetryable = false;
+      let hasRejected = false;
+      queue = queue.flatMap((item) => {
+        if (!expectedIds.has(item.id)) return [item];
+        const result = byId.get(item.id);
+        if (result.status === "retryable") {
+          hasRetryable = true;
+          return [retryItem(item, outcome.retryAfterMs, result.errorCode ?? "retryable")];
+        }
+        removedIds.push(item.id);
+        if (result.status === "rejected") {
+          hasRejected = true;
+          drop(result.errorCode ?? "rejected");
+        }
+        return [];
+      });
+      await persistRetriedItems(
+        queue.filter((item) => expectedIds.has(item.id) && byId.get(item.id)?.status === "retryable")
+      );
+      await persistentQueue?.remove(removedIds).catch(() => void 0);
+      recentSendStatus = hasRetryable ? "retryable" : hasRejected ? "permanent_error" : "accepted";
+      if (hasRetryable) lastRateLimitedAt = dependencies.now().toISOString();
+      scheduleNextQueuedFlush();
+      return queue.length === 0;
+    }
+    if (outcome.kind === "permanent_error") {
+      if (REVOKED_CREDENTIAL_CODES.has(outcome.code)) {
+        remotelyDisabled = true;
+        queue = [];
+        await persistentQueue?.clear().catch(() => void 0);
+      } else {
+        const removedIds = new Set(batch.map((item) => item.id));
+        queue = queue.filter((item) => !removedIds.has(item.id));
+        await persistentQueue?.remove([...removedIds]).catch(() => void 0);
+      }
+      recentSendStatus = "permanent_error";
+      drop(outcome.code);
+      scheduleNextQueuedFlush();
+      return queue.length === 0;
+    }
+    const retryIds = new Set(batch.map((item) => item.id));
+    const retryAfterMs3 = outcome.kind === "retryable" ? outcome.retryAfterMs : 0;
+    queue = queue.map(
+      (item) => retryIds.has(item.id) ? retryItem(item, retryAfterMs3, outcome.code) : item
+    );
+    await persistRetriedItems(queue.filter((item) => retryIds.has(item.id)));
+    recentSendStatus = "retryable";
+    if (outcome.kind === "retryable") lastRateLimitedAt = dependencies.now().toISOString();
+    scheduleNextQueuedFlush();
+    return false;
+  }
+  function telemetryEnvelope(items) {
+    return {
+      protocolVersion: PROTOCOL_VERSION,
+      sdkName: "@devkitio/faultlens",
+      sdkVersion: SDK_VERSION,
+      clientType: options.ingest.mode === "relay" ? "relay" : "browser",
+      expectedEnvironment: options.expectedEnvironment,
+      release: options.release,
+      dist: options.dist ?? "default",
+      buildId: options.buildId ?? options.release,
+      clientBatchId: dependencies.createEventId(),
+      traces: items.flatMap((item) => item.kind === "trace" ? [item.item] : []),
+      spans: items.flatMap((item) => item.kind === "span" ? [item.item] : []),
+      webVitals: items.flatMap((item) => item.kind === "web_vital" ? [item.item] : [])
+    };
+  }
+  function telemetryRetryDelay(item, serverDelayMs) {
+    const jittered = 500 * 2 ** Math.min(10, item.attemptCount) * (0.5 + dependencies.random() * 0.5);
+    return Math.min(3e4, Math.max(serverDelayMs, Math.round(jittered)));
+  }
+  async function performTelemetryFlush() {
+    await remoteConfigPromise;
+    if (telemetryQueue.length === 0) return true;
+    if (!telemetryEnabled || telemetryUnsupported) {
+      telemetryQueue = [];
+      drop(telemetryUnsupported ? "telemetry_unsupported" : "telemetry_disabled");
+      return true;
+    }
+    telemetryQueue = telemetryQueue.filter((queued) => {
+      const samplingKey = queued.kind === "web_vital" ? queued.item.telemetryId : queued.item.traceId;
+      let sampled = telemetrySamplingDecisions.get(samplingKey);
+      if (sampled === void 0) {
+        sampled = dependencies.random() < telemetrySampleRate;
+        telemetrySamplingDecisions.set(samplingKey, sampled);
+      }
+      if (!sampled) drop("telemetry_sampled");
+      return sampled;
+    });
+    if (telemetryQueue.length === 0) return true;
+    const now = dependencies.now().getTime();
+    const batch = telemetryQueue.filter((item) => item.nextAttemptAt <= now).slice(0, 100);
+    if (batch.length === 0) {
+      const nextAttemptAt = Math.min(...telemetryQueue.map((item) => item.nextAttemptAt));
+      scheduleFlush(Math.max(0, nextAttemptAt - now));
+      return false;
+    }
+    const ids = new Set(batch.map((item) => item.item.telemetryId));
+    let outcome;
+    try {
+      outcome = await dependencies.telemetryTransport.send(telemetryEnvelope(batch));
+    } catch {
+      outcome = { kind: "network_error", code: "network_error" };
+    }
+    if (outcome.kind === "unsupported") {
+      telemetryUnsupported = true;
+      telemetryEnabled = false;
+      telemetryQueue = [];
+      drop("telemetry_unsupported");
+      return true;
+    }
+    if (outcome.kind === "batch") {
+      const byId = new Map(outcome.results.map((result) => [result.telemetryId, result]));
+      const complete = outcome.results.length === ids.size && [...ids].every((id) => byId.has(id));
+      telemetryQueue = telemetryQueue.flatMap((item) => {
+        if (!ids.has(item.item.telemetryId)) return [item];
+        const result = complete ? byId.get(item.item.telemetryId) : void 0;
+        if (!result || result.status === "retryable") {
+          const attemptCount = item.attemptCount + 1;
+          return [{
+            ...item,
+            attemptCount,
+            nextAttemptAt: dependencies.now().getTime() + telemetryRetryDelay({ ...item, attemptCount }, outcome.retryAfterMs)
+          }];
+        }
+        if (result.status === "rejected") drop(result.errorCode ?? "telemetry_rejected");
+        return [];
+      });
+    } else if (outcome.kind === "permanent_error") {
+      telemetryQueue = telemetryQueue.filter((item) => !ids.has(item.item.telemetryId));
+      drop(outcome.code);
+    } else {
+      const serverDelayMs = outcome.kind === "retryable" ? outcome.retryAfterMs : 0;
+      telemetryQueue = telemetryQueue.map((item) => {
+        if (!ids.has(item.item.telemetryId)) return item;
+        const attemptCount = item.attemptCount + 1;
+        return {
+          ...item,
+          attemptCount,
+          nextAttemptAt: dependencies.now().getTime() + telemetryRetryDelay({ ...item, attemptCount }, serverDelayMs)
+        };
+      });
+    }
+    if (telemetryQueue.length > 0) {
+      const nextAttemptAt = Math.min(...telemetryQueue.map((item) => item.nextAttemptAt));
+      scheduleFlush(Math.max(0, nextAttemptAt - dependencies.now().getTime()));
+    }
+    return telemetryQueue.length === 0;
+  }
+  async function performFlush() {
+    const [eventResult] = await Promise.all([performEventFlush(), performTelemetryFlush()]);
+    return eventResult;
+  }
+  function flushInternal() {
+    activeFlush ??= performFlush().finally(() => {
+      activeFlush = void 0;
+    });
+    return activeFlush;
+  }
+  async function flush(timeout) {
+    if (sendTimer) {
+      clearTimeout(sendTimer);
+      sendTimer = void 0;
+      sendTimerDueAt = void 0;
+    }
+    let timer;
+    try {
+      return await Promise.race([
+        flushInternal(),
+        new Promise((resolve) => {
+          timer = setTimeout(() => resolve(false), Math.max(0, timeout));
+        })
+      ]);
+    } finally {
+      if (timer) clearTimeout(timer);
+    }
+  }
+  const monitor = {
+    captureException(error, capture = {}) {
+      const event = baseEvent(errorShape(error), capture);
+      if (shouldIgnore(error, event)) return event.eventId;
+      return enqueue(event);
+    },
+    captureMessage(message, capture = {}) {
+      const event = baseEvent({ type: "Message", message: message.slice(0, 32768), stack: [] }, capture);
+      if (shouldIgnore(message, event)) return event.eventId;
+      return enqueue(event);
+    },
+    addBreadcrumb(breadcrumb) {
+      breadcrumbs.push(
+        clientRedact({
+          ...breadcrumb,
+          timestamp: breadcrumb.timestamp ?? dependencies.now().toISOString()
+        })
+      );
+      if (breadcrumbs.length > 50) breadcrumbs.shift();
+    },
+    setUser(value) {
+      user = value ? clientRedact(value) : null;
+    },
+    setContext(name, value) {
+      namedContext.set(name.slice(0, 128), clientRedact(value));
+    },
+    startSpan,
+    withSpan(name, callback, spanOptions = {}) {
+      const span = startSpan(name, spanOptions);
+      return spanContextManager.run(span, () => {
+        try {
+          const result = callback(span);
+          if (result && typeof result.then === "function") {
+            return Promise.resolve(result).then(
+              (value) => {
+                span.end("ok");
+                return value;
+              },
+              (error) => {
+                span.end("error");
+                throw error;
+              }
+            );
+          }
+          span.end("ok");
+          return result;
+        } catch (error) {
+          span.end("error");
+          throw error;
+        }
+      });
+    },
+    captureWebVital,
+    getStatus() {
+      const queuedEventIds = new Set(queue.map((item) => item.event.eventId));
+      return {
+        queueLength: (/* @__PURE__ */ new Set([...queuedEventIds, ...pendingEventIds])).size,
+        recentSendStatus,
+        droppedReasons: { ...droppedReasons },
+        protocolVersion: PROTOCOL_VERSION,
+        sdkVersion: SDK_VERSION,
+        lastRateLimitedAt,
+        remotelyDisabled,
+        telemetryEnabled,
+        telemetryQueueLength: telemetryQueue.length,
+        remoteConfigLastRefreshAt,
+        remoteConfigLastSuccessAt,
+        remoteConfigFailureCode,
+        remoteConfigRefreshFailures
+      };
+    },
+    flush,
+    async close() {
+      closed = true;
+      if (sendTimer) clearTimeout(sendTimer);
+      if (remoteConfigTimer) clearTimeout(remoteConfigTimer);
+      sendTimerDueAt = void 0;
+      return flush(2e3);
+    }
+  };
+  const transportPath = options.ingest.mode === "relay" ? options.ingest.endpoint : new URL(options.ingest.dsn).pathname;
+  const removeGlobalHandlers = overrides.installGlobalHandlers?.(monitor, transportPath) ?? (() => void 0);
+  const originalClose = monitor.close;
+  monitor.close = async () => {
+    removeGlobalHandlers();
+    return originalClose();
+  };
+  return monitor;
+}
+
+export { FetchTelemetryTransport, SDK_VERSION, clientRedact, createMonitorRuntime, formatTraceParent, parseErrorStack, parseRemoteSdkConfig, parseTelemetryTransportResponse, parseTraceParent, parseTransportResponse, traceContextHeaders };