@squasher-ai/browser-logger 0.1.1 → 0.3.0

package/dist/browser-logger.umd.js

@@ -3,60 +3,482 @@
   var __getOwnPropNames = Object.getOwnPropertyNames;
   var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
   var __hasOwnProp = Object.prototype.hasOwnProperty;
-  var __moduleCache = /* @__PURE__ */ new WeakMap;
+  function __accessProp(key) {
+    return this[key];
+  }
   var __toCommonJS = (from) => {
-    var entry = __moduleCache.get(from), desc;
+    var entry = (__moduleCache ??= new WeakMap).get(from), desc;
     if (entry)
       return entry;
     entry = __defProp({}, "__esModule", { value: true });
-    if (from && typeof from === "object" || typeof from === "function")
-      __getOwnPropNames(from).map((key) => !__hasOwnProp.call(entry, key) && __defProp(entry, key, {
-        get: () => from[key],
-        enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
-      }));
+    if (from && typeof from === "object" || typeof from === "function") {
+      for (var key of __getOwnPropNames(from))
+        if (!__hasOwnProp.call(entry, key))
+          __defProp(entry, key, {
+            get: __accessProp.bind(from, key),
+            enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+          });
+    }
     __moduleCache.set(from, entry);
     return entry;
   };
+  var __moduleCache;
+  var __returnValue = (v) => v;
+  function __exportSetter(name, newValue) {
+    this[name] = __returnValue.bind(null, newValue);
+  }
   var __export = (target, all) => {
     for (var name in all)
       __defProp(target, name, {
         get: all[name],
         enumerable: true,
         configurable: true,
-        set: (newValue) => all[name] = () => newValue
+        set: __exportSetter.bind(all, name)
       });
   };
 
   // src/global.ts
   var exports_global = {};
   __export(exports_global, {
-    initBrowserLogger: () => initBrowserLogger,
-    getBrowserLogger: () => getBrowserLogger,
-    flushBrowserLogger: () => flushBrowserLogger,
-    default: () => global_default,
+    BrowserLogger: () => BrowserLogger,
     closeBrowserLogger: () => closeBrowserLogger,
-    BrowserLogger: () => BrowserLogger
+    default: () => global_default,
+    flushBrowserLogger: () => flushBrowserLogger,
+    getBrowserLogger: () => getBrowserLogger,
+    initBrowserLogger: () => initBrowserLogger
   });
 
+  // ../sdk-core/dist/batching/index.js
+  var BODY_ENCODER = new TextEncoder;
+  // ../sdk-core/dist/errors/headers.js
+  function readHeader(headers, name) {
+    if (!headers)
+      return;
+    const get = readProperty(headers, "get");
+    if (isHeaderGetter(get)) {
+      try {
+        const value = get.call(headers, name);
+        return Object.prototype.toString.call(value) === "[object String]" ? String(value) : undefined;
+      } catch {
+        return;
+      }
+    }
+    const normalizedName = name.toLowerCase();
+    for (const [key, value] of Object.entries(Object(headers))) {
+      if (key.toLowerCase() === normalizedName && Object.prototype.toString.call(value) === "[object String]") {
+        return String(value);
+      }
+    }
+    return;
+  }
+  function isHeaderGetter(value) {
+    return Object.prototype.toString.call(value) === "[object Function]";
+  }
+  function readProperty(owner, key) {
+    try {
+      const target = Object(owner);
+      let cursor = target;
+      while (cursor) {
+        const descriptor = Object.getOwnPropertyDescriptor(cursor, key);
+        if (descriptor) {
+          return "value" in descriptor ? descriptor.value : descriptor.get?.call(target);
+        }
+        cursor = Object.getPrototypeOf(cursor);
+      }
+      return;
+    } catch {
+      return;
+    }
+  }
+
+  // ../sdk-core/dist/errors/index.js
+  class SquasherError extends Error {
+    constructor(message) {
+      super(message);
+      this.name = "SquasherError";
+    }
+  }
+
+  class SquasherApiError extends SquasherError {
+    status;
+    body;
+    requestId;
+    constructor(status, body, message, headers) {
+      super(buildMessage(body, message));
+      this.name = "SquasherApiError";
+      this.status = status;
+      this.body = body;
+      this.requestId = readHeader(headers, "x-request-id");
+    }
+    static generate(status, body, fallbackMessage, headers) {
+      if (status === 400)
+        return new BadRequestError(body, fallbackMessage, headers);
+      if (status === 401)
+        return new AuthenticationError(body, fallbackMessage, headers);
+      if (status === 403)
+        return new PermissionDeniedError(body, fallbackMessage, headers);
+      if (status === 404)
+        return new NotFoundError(body, fallbackMessage, headers);
+      if (status === 409)
+        return new ConflictError(body, fallbackMessage, headers);
+      if (status === 422)
+        return new UnprocessableEntityError(body, fallbackMessage, headers);
+      if (status === 429)
+        return new RateLimitError(body, fallbackMessage, headers);
+      if (status >= 500)
+        return new InternalServerError(status, body, fallbackMessage, headers);
+      return new SquasherApiError(status, body, fallbackMessage, headers);
+    }
+  }
+  function buildMessage(body, fallback) {
+    if (body?.error)
+      return body.error;
+    if (body?.message)
+      return body.message;
+    return fallback;
+  }
+
+  class BadRequestError extends SquasherApiError {
+    status = 400;
+    constructor(body, message, headers) {
+      super(400, body, message, headers);
+      this.name = "BadRequestError";
+    }
+  }
+
+  class AuthenticationError extends SquasherApiError {
+    status = 401;
+    constructor(body, message, headers) {
+      super(401, body, message, headers);
+      this.name = "AuthenticationError";
+    }
+  }
+
+  class PermissionDeniedError extends SquasherApiError {
+    status = 403;
+    constructor(body, message, headers) {
+      super(403, body, message, headers);
+      this.name = "PermissionDeniedError";
+    }
+  }
+
+  class NotFoundError extends SquasherApiError {
+    status = 404;
+    constructor(body, message, headers) {
+      super(404, body, message, headers);
+      this.name = "NotFoundError";
+    }
+  }
+
+  class ConflictError extends SquasherApiError {
+    status = 409;
+    constructor(body, message, headers) {
+      super(409, body, message, headers);
+      this.name = "ConflictError";
+    }
+  }
+
+  class UnprocessableEntityError extends SquasherApiError {
+    status = 422;
+    constructor(body, message, headers) {
+      super(422, body, message, headers);
+      this.name = "UnprocessableEntityError";
+    }
+  }
+
+  class RateLimitError extends SquasherApiError {
+    status = 429;
+    constructor(body, message, headers) {
+      super(429, body, message, headers);
+      this.name = "RateLimitError";
+    }
+  }
+
+  class InternalServerError extends SquasherApiError {
+    constructor(status, body, message, headers) {
+      super(status, body, message, headers);
+      this.name = "InternalServerError";
+    }
+  }
+  // ../sdk-core/dist/retry.js
+  var RETRYABLE_STATUSES = new Set([408, 429]);
+  // ../sdk-core/dist/runtime/release.js
+  var JUNK_VALUES = new Set([
+    "",
+    "undefined",
+    "null",
+    "nan",
+    "latest",
+    "unknown",
+    "(none)",
+    "n/a",
+    "none"
+  ]);
+  // ../sdk-core/dist/streaming/index.js
+  function findNewline(buffer, startIndex) {
+    for (let i = startIndex ?? 0;i < buffer.length; i++) {
+      if (buffer[i] === 10)
+        return { preceding: i, index: i + 1, carriage: false };
+      if (buffer[i] === 13)
+        return { preceding: i, index: i + 1, carriage: true };
+    }
+    return null;
+  }
+
+  class LineDecoder {
+    buffer = new Uint8Array;
+    carriageReturnIndex = null;
+    decoder = new TextDecoder("utf-8");
+    decode(chunk) {
+      const next = new Uint8Array(this.buffer.length + chunk.length);
+      next.set(this.buffer);
+      next.set(chunk, this.buffer.length);
+      this.buffer = next;
+      const lines = [];
+      let pat;
+      while ((pat = findNewline(this.buffer, this.carriageReturnIndex)) !== null) {
+        if (pat.carriage && this.carriageReturnIndex == null) {
+          this.carriageReturnIndex = pat.index;
+          continue;
+        }
+        if (this.carriageReturnIndex != null && (pat.index !== this.carriageReturnIndex + 1 || pat.carriage)) {
+          lines.push(this.decoder.decode(this.buffer.subarray(0, this.carriageReturnIndex - 1)));
+          this.buffer = this.buffer.subarray(this.carriageReturnIndex);
+          this.carriageReturnIndex = null;
+          continue;
+        }
+        const endIndex = this.carriageReturnIndex !== null ? pat.preceding - 1 : pat.preceding;
+        lines.push(this.decoder.decode(this.buffer.subarray(0, endIndex)));
+        this.buffer = this.buffer.subarray(pat.index);
+        this.carriageReturnIndex = null;
+      }
+      return lines;
+    }
+    flush() {
+      if (!this.buffer.length)
+        return [];
+      return this.decode(new Uint8Array([10]));
+    }
+  }
+
+  class SSEDecoder {
+    event = null;
+    data = [];
+    chunks = [];
+    decode(line) {
+      const stripped = line.endsWith("\r") ? line.slice(0, -1) : line;
+      if (!stripped) {
+        if (!this.event && this.data.length === 0)
+          return null;
+        const ev = {
+          event: this.event,
+          data: this.data.join(`
+`),
+          raw: this.chunks
+        };
+        this.event = null;
+        this.data = [];
+        this.chunks = [];
+        return ev;
+      }
+      this.chunks.push(stripped);
+      if (stripped.startsWith(":"))
+        return null;
+      const colon = stripped.indexOf(":");
+      const fieldname = colon === -1 ? stripped : stripped.slice(0, colon);
+      let value = colon === -1 ? "" : stripped.slice(colon + 1);
+      if (value.startsWith(" "))
+        value = value.slice(1);
+      if (fieldname === "event")
+        this.event = value;
+      else if (fieldname === "data")
+        this.data.push(value);
+      return null;
+    }
+  }
+  async function* iterSSEChunks(body) {
+    const lineDecoder = new LineDecoder;
+    const sseDecoder = new SSEDecoder;
+    const reader = body.getReader();
+    try {
+      for (;; ) {
+        const { value, done } = await reader.read();
+        if (done)
+          break;
+        for (const line of lineDecoder.decode(value)) {
+          const ev = sseDecoder.decode(line);
+          if (ev)
+            yield ev;
+        }
+      }
+      for (const line of lineDecoder.flush()) {
+        const ev = sseDecoder.decode(line);
+        if (ev)
+          yield ev;
+      }
+    } finally {
+      try {
+        reader.releaseLock();
+      } catch {}
+    }
+  }
+  function isAbortError(e) {
+    return e.name === "AbortError" || e.name === "SquasherUserAbortError";
+  }
+  function coerceErrorBody(value) {
+    if (Object.prototype.toString.call(value) === "[object String]") {
+      return { error: String(value) };
+    }
+    if (isSSEDataObject(value)) {
+      const out = {};
+      if (Object.prototype.toString.call(value.error) === "[object String]") {
+        out.error = String(value.error);
+      }
+      if (Object.prototype.toString.call(value.message) === "[object String]") {
+        out.message = String(value.message);
+      }
+      if (Object.prototype.toString.call(value.code) === "[object String]") {
+        out.code = String(value.code);
+      }
+      return out;
+    }
+    return null;
+  }
+  function isSSEDataObject(value) {
+    return value instanceof Object && !Array.isArray(value);
+  }
+
+  class Stream {
+    controller;
+    iteratorFactory;
+    constructor(iteratorFactory, controller) {
+      this.controller = controller;
+      this.iteratorFactory = iteratorFactory;
+    }
+    static fromSSEResponse(response, controller, parse) {
+      let consumed = false;
+      async function* iterator() {
+        if (consumed) {
+          throw new Error("Cannot iterate over a consumed stream, use `.tee()` to split the stream.");
+        }
+        consumed = true;
+        if (!response.body) {
+          controller.abort();
+          throw new Error("Attempted to iterate over a response with no body");
+        }
+        let done = false;
+        try {
+          for await (const sse of iterSSEChunks(response.body)) {
+            if (done)
+              continue;
+            if (sse.data.startsWith("[DONE]")) {
+              done = true;
+              continue;
+            }
+            const parsed = JSON.parse(sse.data);
+            if (isSSEDataObject(parsed) && "error" in parsed) {
+              const body = coerceErrorBody(parsed.error);
+              throw SquasherApiError.generate(response.status, body, body?.error ?? body?.message ?? "stream error", response.headers);
+            }
+            yield parse ? parse(parsed) : parsed;
+          }
+          done = true;
+        } catch (e) {
+          if (e instanceof Error && isAbortError(e))
+            return;
+          throw e;
+        } finally {
+          if (!done)
+            controller.abort();
+        }
+      }
+      return new Stream(iterator, controller);
+    }
+    [Symbol.asyncIterator]() {
+      return this.iteratorFactory();
+    }
+    tee() {
+      const left = [];
+      const right = [];
+      const iterator = this.iteratorFactory();
+      const teeIterator = (queue) => ({
+        next: () => {
+          if (queue.length === 0) {
+            const result = Promise.resolve(iterator.next());
+            left.push(result);
+            right.push(result);
+          }
+          const queued = queue.shift();
+          if (!queued)
+            throw new Error("Stream tee queue was empty");
+          return queued;
+        }
+      });
+      return [
+        new Stream(() => teeIterator(left), this.controller),
+        new Stream(() => teeIterator(right), this.controller)
+      ];
+    }
+    toReadableStream() {
+      const factory = this.iteratorFactory;
+      let iter = null;
+      const encoder = new TextEncoder;
+      return new ReadableStream({
+        start() {
+          iter = factory();
+        },
+        async pull(ctrl) {
+          try {
+            if (!iter) {
+              ctrl.close();
+              return;
+            }
+            const { value, done } = await iter.next();
+            if (done) {
+              ctrl.close();
+              return;
+            }
+            ctrl.enqueue(encoder.encode(JSON.stringify(value) + `
+`));
+          } catch (err) {
+            ctrl.error(err);
+          }
+        },
+        async cancel() {
+          await iter?.return?.();
+        }
+      });
+    }
+  }
+
+  // ../sdk-core/dist/index.js
+  var DEFAULT_INGEST_ENDPOINT = "https://ingest.squasher.ai";
+  var TRUTHY = new Set(["1", "true", "yes", "on"]);
+
   // src/serializer.ts
   var SDK_NAME = "@squasher-ai/browser-logger";
-  var SDK_VERSION = "0.1.0";
+  var SDK_VERSION = "0.3.0";
+  var BOOLEAN_TAG = "[object Boolean]";
+  var FUNCTION_TAG = "[object Function]";
+  var NUMBER_TAG = "[object Number]";
+  var STRING_TAG = "[object String]";
+  var BIGINT_TAG = "[object BigInt]";
+  var SYMBOL_TAG = "[object Symbol]";
+  var UNDEFINED_TAG = "[object Undefined]";
   function buildConsoleEvent(args, level) {
     const error = findError(args);
-    const pageUrl = getPageUrl();
-    const userAgent = getUserAgent();
+    const pageUrl = globalThis.location?.href;
+    const userAgent = globalThis.navigator?.userAgent;
     const extra = {
       console_arguments: Array.from(args, (arg) => toJsonValue(arg)),
       console_method: level === "warning" ? "warn" : "error"
     };
-    if (pageUrl) {
+    if (pageUrl)
       extra.page_url = pageUrl;
-    }
-    if (userAgent) {
+    if (userAgent)
       extra.user_agent = userAgent;
-    }
     return {
-      message: buildMessage(args, error),
+      message: buildMessage2(args, error),
       type: error?.name,
       stack: error?.stack,
       level,
@@ -69,128 +491,167 @@
       extra
     };
   }
-  function buildMessage(args, error) {
-    if (args.length === 0) {
+  function buildMessage2(args, error) {
+    if (args.length === 0)
       return "console.error";
-    }
-    const parts = Array.from(args, (arg) => formatMessagePart(arg)).filter((part) => part.length > 0);
-    if (parts.length > 0) {
+    const parts = Array.from(args, formatMessagePart).filter((part) => part.length > 0);
+    if (parts.length > 0)
       return parts.join(" ");
-    }
-    if (error?.message) {
-      return error.message;
-    }
-    return "console.error";
+    return error?.message || "console.error";
   }
   function formatMessagePart(value) {
-    if (value instanceof Error) {
+    if (value instanceof Error)
       return value.message || value.name || "Error";
-    }
-    if (typeof value === "string") {
-      return value;
-    }
-    if (typeof value === "number" || typeof value === "boolean" || typeof value === "bigint" || typeof value === "symbol") {
-      return String(value);
-    }
-    if (value === null) {
+    if (value === null)
       return "null";
-    }
-    if (typeof value === "undefined") {
+    const tag = valueTag(value);
+    if (tag === UNDEFINED_TAG)
       return "undefined";
+    if (tag === STRING_TAG || tag === NUMBER_TAG || tag === BOOLEAN_TAG || tag === BIGINT_TAG || tag === SYMBOL_TAG) {
+      return String(value);
     }
     return stringifyJsonValue(toJsonValue(value));
   }
   function findError(args) {
     return Array.from(args).find((arg) => arg instanceof Error);
   }
-  function getPageUrl() {
-    if (typeof location === "undefined") {
-      return;
-    }
-    return location.href;
-  }
-  function getUserAgent() {
-    if (typeof navigator === "undefined") {
-      return;
-    }
-    return navigator.userAgent;
-  }
   function stringifyJsonValue(value) {
-    if (typeof value === "string") {
-      return value;
-    }
-    return JSON.stringify(value);
+    return valueTag(value) === STRING_TAG ? String(value) : JSON.stringify(value);
   }
   function toJsonValue(value) {
-    if (value === null) {
+    if (value === null)
       return null;
-    }
-    if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
-      return value;
-    }
-    if (typeof value === "bigint" || typeof value === "symbol") {
+    const tag = valueTag(value);
+    if (tag === STRING_TAG)
       return String(value);
-    }
-    if (typeof value === "undefined") {
+    if (tag === NUMBER_TAG)
+      return Number(value);
+    if (tag === BOOLEAN_TAG)
+      return Boolean(value);
+    if (tag === BIGINT_TAG || tag === SYMBOL_TAG)
+      return String(value);
+    if (tag === UNDEFINED_TAG)
       return "undefined";
-    }
-    if (typeof value === "function") {
-      return `[Function ${value.name || "anonymous"}]`;
-    }
+    if (tag === FUNCTION_TAG)
+      return functionLabel(value);
     if (value instanceof Error) {
       const serializedError = {
         name: value.name,
         message: value.message
       };
-      if (value.stack) {
+      if (value.stack)
         serializedError.stack = value.stack;
-      }
       return serializedError;
     }
-    if (Array.isArray(value)) {
+    if (Array.isArray(value))
       return value.map((item) => toJsonValue(item));
-    }
     return serializeObject(value);
   }
   function serializeObject(value) {
     const seen = new WeakSet;
     const json = JSON.stringify(value, (_key, nestedValue) => {
-      if (typeof nestedValue === "bigint" || typeof nestedValue === "symbol") {
+      const tag = valueTag(nestedValue);
+      if (tag === BIGINT_TAG || tag === SYMBOL_TAG)
         return String(nestedValue);
-      }
-      if (typeof nestedValue === "function") {
-        return `[Function ${nestedValue.name || "anonymous"}]`;
-      }
+      if (tag === FUNCTION_TAG)
+        return functionLabel(nestedValue);
       if (nestedValue instanceof Error) {
         const serializedError = {
           name: nestedValue.name,
           message: nestedValue.message
         };
-        if (nestedValue.stack) {
+        if (nestedValue.stack)
           serializedError.stack = nestedValue.stack;
-        }
         return serializedError;
       }
-      if (typeof nestedValue === "object" && nestedValue !== null) {
-        if (seen.has(nestedValue)) {
+      if (isReferenceTag(tag) && nestedValue !== null) {
+        if (seen.has(nestedValue))
           return "[Circular]";
-        }
         seen.add(nestedValue);
       }
       return nestedValue;
     });
-    if (!json) {
+    if (!json)
       return String(value);
+    const parsed = JSON.parse(json);
+    return parsed;
+  }
+  function valueTag(value) {
+    return Object.prototype.toString.call(value);
+  }
+  function isReferenceTag(tag) {
+    return ![BIGINT_TAG, BOOLEAN_TAG, NUMBER_TAG, STRING_TAG, SYMBOL_TAG, UNDEFINED_TAG].includes(tag);
+  }
+  function functionLabel(value) {
+    const source = String(value);
+    const match = source.match(/^(?:async\s+)?function\s*([^\s(]*)/);
+    return `[Function ${match?.[1] || "anonymous"}]`;
+  }
+
+  // ../result-utils/dist/index.js
+  function toError(cause, fallbackMessage = "Unexpected error") {
+    if (cause instanceof Error) {
+      return cause;
+    }
+    const nestedError = readProperty2(cause, "error");
+    if (nestedError instanceof Error)
+      return nestedError;
+    const messageValue = readProperty2(cause, "message");
+    if (Object.prototype.toString.call(messageValue) === "[object String]") {
+      const message = String(messageValue);
+      if (message.length > 0)
+        return new Error(message);
+    }
+    if (Object.prototype.toString.call(cause) === "[object String]") {
+      const message = String(cause);
+      if (message.length > 0)
+        return new Error(message);
+    }
+    return new Error(fallbackMessage, { cause });
+  }
+  function readProperty2(owner, key) {
+    try {
+      const target = Object(owner);
+      let cursor = target;
+      while (cursor) {
+        const descriptor = Object.getOwnPropertyDescriptor(cursor, key);
+        if (descriptor) {
+          return "value" in descriptor ? descriptor.value : descriptor.get?.call(target);
+        }
+        cursor = Object.getPrototypeOf(cursor);
+      }
+      return;
+    } catch {
+      return;
+    }
+  }
+  function attempt(options) {
+    try {
+      return options.try();
+    } catch (cause) {
+      const preservedCause = cause;
+      return options.catch({ cause: preservedCause, error: toError(preservedCause) });
+    } finally {
+      options.finally?.();
+    }
+  }
+  async function attemptAsync(options) {
+    try {
+      return await options.try();
+    } catch (cause) {
+      const preservedCause = cause;
+      return await options.catch({ cause: preservedCause, error: toError(preservedCause) });
+    } finally {
+      await options.finally?.();
     }
-    return JSON.parse(json);
   }
 
   // src/transport.ts
-  var DEFAULT_ENDPOINT = "https://ingest.squasher.ai";
   var DEFAULT_BATCH_SIZE = 10;
   var DEFAULT_FLUSH_INTERVAL_MS = 5000;
 
   class BrowserLoggerTransport {
+    runtime;
     apiKey;
     projectId;
     endpoint;
@@ -201,14 +662,15 @@
       this.flushOnPageHide();
     };
     handleVisibilityChange = () => {
-      if (typeof document !== "undefined" && document.visibilityState === "hidden") {
+      if (this.runtime.document?.visibilityState === "hidden") {
         this.flushOnPageHide();
       }
     };
-    constructor(config) {
+    constructor(config, runtime = defaultBrowserLoggerRuntime()) {
+      this.runtime = runtime;
       this.apiKey = config.apiKey;
       this.projectId = config.projectId;
-      this.endpoint = normalizeEndpoint(config.endpoint ?? DEFAULT_ENDPOINT);
+      this.endpoint = normalizeEndpoint(config.endpoint ?? DEFAULT_INGEST_ENDPOINT);
       this.flushTimer = setInterval(() => {
         this.flush();
       }, DEFAULT_FLUSH_INTERVAL_MS);
@@ -262,49 +724,43 @@
       });
     }
     installListeners() {
-      if (typeof document !== "undefined") {
-        document.addEventListener("visibilitychange", this.handleVisibilityChange);
-      }
-      if (typeof window !== "undefined") {
-        window.addEventListener("pagehide", this.handlePageHide);
-        window.addEventListener("beforeunload", this.handlePageHide);
-      }
+      this.runtime.document?.addEventListener("visibilitychange", this.handleVisibilityChange);
+      this.runtime.window?.addEventListener("pagehide", this.handlePageHide);
+      this.runtime.window?.addEventListener("beforeunload", this.handlePageHide);
     }
     removeListeners() {
-      if (typeof document !== "undefined") {
-        document.removeEventListener("visibilitychange", this.handleVisibilityChange);
-      }
-      if (typeof window !== "undefined") {
-        window.removeEventListener("pagehide", this.handlePageHide);
-        window.removeEventListener("beforeunload", this.handlePageHide);
-      }
+      this.runtime.document?.removeEventListener("visibilitychange", this.handleVisibilityChange);
+      this.runtime.window?.removeEventListener("pagehide", this.handlePageHide);
+      this.runtime.window?.removeEventListener("beforeunload", this.handlePageHide);
     }
     trySendBeacon(body) {
-      if (typeof navigator === "undefined" || typeof navigator.sendBeacon !== "function") {
-        return false;
-      }
-      try {
-        const blob = new Blob([body], { type: "application/json" });
-        return navigator.sendBeacon(this.getBeaconUrl(), blob);
-      } catch {
+      const sendBeacon = this.runtime.navigator?.sendBeacon;
+      if (!sendBeacon)
         return false;
-      }
+      return attempt({
+        try: () => {
+          const blob = new Blob([body], { type: "application/json" });
+          return sendBeacon.call(this.runtime.navigator, this.getBeaconUrl(), blob);
+        },
+        catch: () => false
+      });
     }
     async sendFetch(body) {
-      try {
-        const response = await fetch(this.getIngestUrl(), {
-          method: "POST",
-          headers: {
-            "Content-Type": "application/json",
-            "x-squasher-key": this.apiKey
-          },
-          body,
-          keepalive: true
-        });
-        return response.ok;
-      } catch {
-        return false;
-      }
+      return attemptAsync({
+        try: async () => {
+          const response = await this.runtime.fetcher(this.getIngestUrl(), {
+            method: "POST",
+            headers: {
+              "Content-Type": "application/json",
+              "x-squasher-key": this.apiKey
+            },
+            body,
+            keepalive: true
+          });
+          return response.ok;
+        },
+        catch: () => false
+      });
     }
     getIngestUrl() {
       return `${this.endpoint}/v1/ingest/${this.projectId}`;
@@ -313,6 +769,14 @@
       return `${this.getIngestUrl()}?key=${encodeURIComponent(this.apiKey)}`;
     }
   }
+  function defaultBrowserLoggerRuntime() {
+    return {
+      document: globalThis.document,
+      fetcher: (...args) => fetch(...args),
+      navigator: globalThis.navigator,
+      window: globalThis.window
+    };
+  }
   function normalizeEndpoint(endpoint) {
     return endpoint.replace(/\/+$/, "");
   }
@@ -322,8 +786,6 @@
   }
 
   // src/browser-logger.ts
-  var DEFAULT_ENDPOINT2 = "https://ingest.squasher.ai";
-
   class BrowserLogger {
     config;
     transport;
@@ -356,7 +818,7 @@
       }
       const originalConsoleError = this.originalConsoleError;
       console.error = (...args) => {
-        Reflect.apply(originalConsoleError, console, args);
+        originalConsoleError.call(console, ...args);
         this.transport.enqueue(buildConsoleEvent(args, "error"));
       };
       this.installed = true;
@@ -373,7 +835,7 @@
     return {
       apiKey: config.apiKey,
       projectId: config.projectId,
-      endpoint: config.endpoint ?? DEFAULT_ENDPOINT2,
+      endpoint: config.endpoint ?? DEFAULT_INGEST_ENDPOINT,
       captureConsoleErrors: config.captureConsoleErrors ?? true
     };
   }
@@ -415,6 +877,11 @@
     init: initBrowserLogger,
     initBrowserLogger
   };
-  globalThis.SquasherBrowserLogger = browserLoggerGlobal;
+  Object.defineProperty(globalThis, "SquasherBrowserLogger", {
+    configurable: true,
+    enumerable: true,
+    value: browserLoggerGlobal,
+    writable: true
+  });
   var global_default = browserLoggerGlobal;
 })();