@devkitio/faultlens 0.1.5

package/dist/chunk-K63I3OJT.js

@@ -0,0 +1,154 @@
+import { createMonitorRuntime } from './chunk-LRHXSFK2.js';
+
+// src/browser-queue.ts
+var DATABASE_NAME = "faultlens";
+var STORE_NAME = "events";
+var MAX_BYTES = 5 * 1024 * 1024;
+var MAX_ITEMS = 50;
+var MAX_AGE_MS = 24 * 60 * 60 * 1e3;
+var IndexedDbEventQueue = class {
+  databasePromise;
+  static available() {
+    return typeof indexedDB !== "undefined";
+  }
+  database() {
+    this.databasePromise ??= new Promise((resolve, reject) => {
+      const request = indexedDB.open(DATABASE_NAME, 1);
+      request.onupgradeneeded = () => {
+        const database = request.result;
+        if (!database.objectStoreNames.contains(STORE_NAME)) {
+          const store = database.createObjectStore(STORE_NAME, { keyPath: "id" });
+          store.createIndex("enqueuedAt", "enqueuedAt");
+        }
+      };
+      request.onsuccess = () => resolve(request.result);
+      request.onerror = () => reject(request.error ?? new Error("IndexedDB \u6253\u5F00\u5931\u8D25"));
+    });
+    return this.databasePromise;
+  }
+  async all() {
+    const database = await this.database();
+    return new Promise((resolve, reject) => {
+      const request = database.transaction(STORE_NAME, "readonly").objectStore(STORE_NAME).getAll();
+      request.onsuccess = () => resolve(request.result.sort((a, b) => a.enqueuedAt - b.enqueuedAt));
+      request.onerror = () => reject(request.error ?? new Error("IndexedDB \u8BFB\u53D6\u5931\u8D25"));
+    });
+  }
+  async load(now) {
+    const items = await this.all();
+    const expired = items.filter((item) => now - item.enqueuedAt > MAX_AGE_MS).map((item) => item.id);
+    if (expired.length > 0) await this.remove(expired);
+    return items.filter((item) => now - item.enqueuedAt <= MAX_AGE_MS).slice(-MAX_ITEMS);
+  }
+  async put(item) {
+    const database = await this.database();
+    await new Promise((resolve, reject) => {
+      const request = database.transaction(STORE_NAME, "readwrite").objectStore(STORE_NAME).put(item);
+      request.onsuccess = () => resolve();
+      request.onerror = () => reject(request.error ?? new Error("IndexedDB \u5199\u5165\u5931\u8D25"));
+    });
+    const items = await this.all();
+    let bytes = items.reduce((total, current) => total + current.bytes, 0);
+    const removeIds = [];
+    for (const current of items) {
+      if (items.length - removeIds.length <= MAX_ITEMS && bytes <= MAX_BYTES) break;
+      removeIds.push(current.id);
+      bytes -= current.bytes;
+    }
+    if (removeIds.length > 0) await this.remove(removeIds);
+  }
+  async remove(ids) {
+    if (ids.length === 0) return;
+    const database = await this.database();
+    await new Promise((resolve, reject) => {
+      const transaction = database.transaction(STORE_NAME, "readwrite");
+      const store = transaction.objectStore(STORE_NAME);
+      for (const id of ids) store.delete(id);
+      transaction.oncomplete = () => resolve();
+      transaction.onerror = () => reject(transaction.error ?? new Error("IndexedDB \u5220\u9664\u5931\u8D25"));
+    });
+  }
+  async clear() {
+    const database = await this.database();
+    await new Promise((resolve, reject) => {
+      const request = database.transaction(STORE_NAME, "readwrite").objectStore(STORE_NAME).clear();
+      request.onsuccess = () => resolve();
+      request.onerror = () => reject(request.error ?? new Error("IndexedDB \u6E05\u7A7A\u5931\u8D25"));
+    });
+  }
+};
+var BrowserSendLease = class {
+  owner = `${Date.now().toString(36)}-${Math.random().toString(36).slice(2)}`;
+  key = "faultlens:send-lease";
+  static available() {
+    try {
+      return typeof localStorage !== "undefined";
+    } catch {
+      return false;
+    }
+  }
+  acquire(now, durationMs = 1e4) {
+    try {
+      const current = JSON.parse(localStorage.getItem(this.key) ?? "null");
+      if (current && current.owner !== this.owner && current.expiresAt > now) return false;
+      localStorage.setItem(this.key, JSON.stringify({ owner: this.owner, expiresAt: now + durationMs }));
+      const confirmed = JSON.parse(localStorage.getItem(this.key) ?? "null");
+      return confirmed?.owner === this.owner;
+    } catch {
+      return true;
+    }
+  }
+  release() {
+    try {
+      const current = JSON.parse(localStorage.getItem(this.key) ?? "null");
+      if (current?.owner === this.owner) localStorage.removeItem(this.key);
+    } catch {
+    }
+  }
+};
+
+// src/global-handlers.ts
+function installGlobalHandlers(monitor, transportPath) {
+  if (typeof window === "undefined") return () => void 0;
+  const onError = (event) => {
+    if (event.filename?.includes(transportPath)) return;
+    if (event.error) {
+      monitor.captureException(event.error, { handled: false, mechanism: "window.error" });
+      return;
+    }
+    const target = event.target;
+    if (target instanceof HTMLScriptElement || target instanceof HTMLLinkElement || target instanceof HTMLImageElement) {
+      const resource = target instanceof HTMLLinkElement ? target.href : target.src;
+      if (!resource.includes(transportPath)) {
+        monitor.captureMessage("\u524D\u7AEF\u8D44\u6E90\u52A0\u8F7D\u5931\u8D25", {
+          handled: false,
+          mechanism: "resource.error",
+          context: { tagName: target.tagName, resource }
+        });
+      }
+    }
+  };
+  const onUnhandledRejection = (event) => {
+    monitor.captureException(event.reason, {
+      handled: false,
+      mechanism: "unhandledrejection"
+    });
+  };
+  window.addEventListener("error", onError, true);
+  window.addEventListener("unhandledrejection", onUnhandledRejection);
+  return () => {
+    window.removeEventListener("error", onError, true);
+    window.removeEventListener("unhandledrejection", onUnhandledRejection);
+  };
+}
+
+// src/index.ts
+function createErrorMonitor(options) {
+  return createMonitorRuntime(options, {
+    ...IndexedDbEventQueue.available() ? { persistentQueue: new IndexedDbEventQueue() } : {},
+    ...BrowserSendLease.available() ? { sendLease: new BrowserSendLease() } : {},
+    installGlobalHandlers
+  });
+}
+
+export { createErrorMonitor };

package/dist/chunk-LRHXSFK2.js

@@ -0,0 +1,535 @@
+// ../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 retryAfterMs(response, body) {
+  const value = response.headers.get("retry-after");
+  if (value && /^\d+$/.test(value)) return Number(value) * 1e3;
+  if (typeof body === "object" && body !== null && "retryAfterMs" in body && typeof body.retryAfterMs === "number") {
+    return Math.max(0, body.retryAfterMs);
+  }
+  return 1e3;
+}
+var FetchTransport = class {
+  constructor(ingest, fetcher = fetch) {
+    this.ingest = ingest;
+    this.fetcher = fetcher;
+  }
+  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
+      });
+      let body;
+      try {
+        body = await response.json();
+      } catch {
+        body = void 0;
+      }
+      if (response.status === 202) return { kind: "accepted" };
+      if (response.status === 429 || response.status >= 500) {
+        return { kind: "retryable", retryAfterMs: retryAfterMs(response, body) };
+      }
+      const code = typeof body === "object" && body !== null && "code" in body ? String(body.code) : `http_${response.status}`;
+      return { kind: "permanent_error", code };
+    } catch {
+      return { kind: "network_error" };
+    }
+  }
+  async loadRemoteConfig() {
+    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.ok) return void 0;
+      const value = await response.json();
+      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 } : {}
+      };
+    } catch {
+      return void 0;
+    }
+  }
+};
+
+// src/monitor.ts
+var SDK_VERSION = "0.1.5";
+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 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),
+    now: overrides.now ?? (() => /* @__PURE__ */ new Date()),
+    random: overrides.random ?? Math.random,
+    createEventId: overrides.createEventId ?? eventId
+  };
+  const 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 = {};
+  let queueLimit = Math.min(50, Math.max(1, options.queueLimit ?? 50));
+  let sampleRate = Math.min(1, Math.max(0, options.sampleRate ?? 1));
+  let errorTypeAllowlist;
+  let user = null;
+  let closed = false;
+  let sendTimer;
+  let recentSendStatus = "idle";
+  let lastRateLimitedAt = null;
+  let remotelyDisabled = false;
+  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({ event: item.event, enqueuedAt: item.enqueuedAt });
+      }
+    }
+  }).catch(() => drop("indexeddb_unavailable"));
+  void dependencies.transport.loadRemoteConfig?.().then((config) => {
+    if (!config) return;
+    if (config.enabled === false) remotelyDisabled = true;
+    if (typeof config.sampleRate === "number") sampleRate = Math.min(sampleRate, Math.max(0, config.sampleRate));
+    if (typeof config.queueLimit === "number") queueLimit = Math.min(queueLimit, Math.max(1, config.queueLimit));
+    if (config.errorTypeAllowlist) errorTypeAllowlist = new Set(config.errorTypeAllowlist);
+  }).catch(() => void 0);
+  function drop(reason) {
+    droppedReasons[reason] = (droppedReasons[reason] ?? 0) + 1;
+  }
+  function scheduleFlush() {
+    if (sendTimer || closed) return;
+    sendTimer = setTimeout(() => {
+      sendTimer = void 0;
+      void flushInternal();
+    }, 100);
+  }
+  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) {
+        queue.shift();
+        drop("queue_limit");
+      }
+      queue.push({ event: sanitized, enqueuedAt: dependencies.now().getTime() });
+      void persistentQueue?.put({
+        id: sanitized.eventId,
+        event: sanitized,
+        enqueuedAt: dependencies.now().getTime(),
+        bytes: size
+      }).catch(() => drop("indexeddb_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"
+    };
+    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)
+    };
+  }
+  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 flushInternal() {
+    await restorePromise;
+    await Promise.all([...pending]);
+    const expiredBefore = dependencies.now().getTime() - 24 * 60 * 60 * 1e3;
+    while (queue[0] && queue[0].enqueuedAt < expiredBefore) {
+      queue.shift();
+      drop("queue_expired");
+    }
+    if (queue.length === 0) return true;
+    const batch = queue.slice(0, 20);
+    if (sendLease && !sendLease.acquire(dependencies.now().getTime())) return false;
+    recentSendStatus = "sending";
+    const outcome = await dependencies.transport.send(envelope(batch.map((item) => item.event)));
+    sendLease?.release();
+    if (outcome.kind === "accepted" || outcome.kind === "permanent_error") {
+      const credentialRevoked = outcome.kind === "permanent_error" && REVOKED_CREDENTIAL_CODES.has(outcome.code);
+      if (credentialRevoked) {
+        remotelyDisabled = true;
+        queue.splice(0, queue.length);
+        void persistentQueue?.clear().catch(() => void 0);
+      } else {
+        queue.splice(0, batch.length);
+        void persistentQueue?.remove(batch.map((item) => item.event.eventId)).catch(() => void 0);
+      }
+      recentSendStatus = outcome.kind === "accepted" ? "accepted" : "permanent_error";
+      if (outcome.kind === "permanent_error") drop(outcome.code);
+      return queue.length === 0;
+    }
+    recentSendStatus = "retryable";
+    if (outcome.kind === "retryable") lastRateLimitedAt = dependencies.now().toISOString();
+    return false;
+  }
+  async function flush(timeout) {
+    if (sendTimer) {
+      clearTimeout(sendTimer);
+      sendTimer = 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));
+    },
+    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
+      };
+    },
+    flush,
+    async close() {
+      closed = true;
+      if (sendTimer) clearTimeout(sendTimer);
+      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 { SDK_VERSION, clientRedact, createMonitorRuntime, parseErrorStack };