@moonwatch/js 0.1.8

package/dist/index.mjs

@@ -0,0 +1,860 @@
+import {
+  __privateAdd,
+  __privateMethod
+} from "./chunk-JKIIIVNW.mjs";
+
+// ../node_modules/non-error/index.js
+var isNonErrorSymbol = /* @__PURE__ */ Symbol("isNonError");
+function defineProperty(object, key, value) {
+  Object.defineProperty(object, key, {
+    value,
+    writable: false,
+    enumerable: false,
+    configurable: false
+  });
+}
+function stringify(value) {
+  if (value === void 0) {
+    return "undefined";
+  }
+  if (value === null) {
+    return "null";
+  }
+  if (typeof value === "string") {
+    return value;
+  }
+  if (typeof value === "number" || typeof value === "boolean") {
+    return String(value);
+  }
+  if (typeof value === "bigint") {
+    return `${value}n`;
+  }
+  if (typeof value === "symbol") {
+    return value.toString();
+  }
+  if (typeof value === "function") {
+    return `[Function${value.name ? ` ${value.name}` : " (anonymous)"}]`;
+  }
+  if (value instanceof Error) {
+    try {
+      return String(value);
+    } catch {
+      return "<Unserializable error>";
+    }
+  }
+  try {
+    return JSON.stringify(value);
+  } catch {
+    try {
+      return String(value);
+    } catch {
+      return "<Unserializable value>";
+    }
+  }
+}
+var _NonError_static, handleCallback_fn;
+var _NonError = class _NonError extends Error {
+  constructor(value, { superclass: Superclass = Error } = {}) {
+    if (_NonError.isNonError(value)) {
+      return value;
+    }
+    if (value instanceof Error) {
+      throw new TypeError("Do not pass Error instances to NonError. Throw the error directly instead.");
+    }
+    super(`Non-error value: ${stringify(value)}`);
+    if (Superclass !== Error) {
+      Object.setPrototypeOf(this, Superclass.prototype);
+    }
+    defineProperty(this, "name", "NonError");
+    defineProperty(this, isNonErrorSymbol, true);
+    defineProperty(this, "isNonError", true);
+    defineProperty(this, "value", value);
+  }
+  static isNonError(value) {
+    return value?.[isNonErrorSymbol] === true;
+  }
+  static try(callback) {
+    var _a;
+    return __privateMethod(_a = _NonError, _NonError_static, handleCallback_fn).call(_a, callback, []);
+  }
+  static wrap(callback) {
+    return (...arguments_) => {
+      var _a;
+      return __privateMethod(_a = _NonError, _NonError_static, handleCallback_fn).call(_a, callback, arguments_);
+    };
+  }
+  // This makes instanceof work even when using the `superclass` option
+  static [Symbol.hasInstance](instance) {
+    return _NonError.isNonError(instance);
+  }
+};
+_NonError_static = new WeakSet();
+handleCallback_fn = function(callback, arguments_) {
+  try {
+    const result = callback(...arguments_);
+    if (result && typeof result.then === "function") {
+      return (async () => {
+        try {
+          return await result;
+        } catch (error) {
+          if (error instanceof Error) {
+            throw error;
+          }
+          throw new _NonError(error);
+        }
+      })();
+    }
+    return result;
+  } catch (error) {
+    if (error instanceof Error) {
+      throw error;
+    }
+    throw new _NonError(error);
+  }
+};
+__privateAdd(_NonError, _NonError_static);
+var NonError = _NonError;
+
+// ../node_modules/serialize-error/error-constructors.js
+var list = [
+  // Native ES errors https://262.ecma-international.org/12.0/#sec-well-known-intrinsic-objects
+  Error,
+  EvalError,
+  RangeError,
+  ReferenceError,
+  SyntaxError,
+  TypeError,
+  URIError,
+  AggregateError,
+  // Built-in errors
+  globalThis.DOMException,
+  // Node-specific errors
+  // https://nodejs.org/api/errors.html
+  globalThis.AssertionError,
+  globalThis.SystemError
+].filter(Boolean).map((constructor) => [constructor.name, constructor]);
+var errorConstructors = new Map(list);
+var errorFactories = /* @__PURE__ */ new Map();
+
+// ../node_modules/serialize-error/index.js
+var errorProperties = [
+  {
+    property: "name",
+    enumerable: false
+  },
+  {
+    property: "message",
+    enumerable: false
+  },
+  {
+    property: "stack",
+    enumerable: false
+  },
+  {
+    property: "code",
+    enumerable: true
+  },
+  {
+    property: "cause",
+    enumerable: false
+  },
+  {
+    property: "errors",
+    enumerable: false
+  }
+];
+var toJsonWasCalled = /* @__PURE__ */ new WeakSet();
+var toJSON = (from) => {
+  toJsonWasCalled.add(from);
+  const json = from.toJSON();
+  toJsonWasCalled.delete(from);
+  return json;
+};
+var newError = (name) => {
+  if (name === "NonError") {
+    return new NonError();
+  }
+  const factory = errorFactories.get(name);
+  if (factory) {
+    return factory();
+  }
+  const ErrorConstructor = errorConstructors.get(name) ?? Error;
+  return ErrorConstructor === AggregateError ? new ErrorConstructor([]) : new ErrorConstructor();
+};
+var destroyCircular = ({
+  from,
+  seen,
+  to,
+  forceEnumerable,
+  maxDepth,
+  depth,
+  useToJSON,
+  serialize
+}) => {
+  if (!to) {
+    if (Array.isArray(from)) {
+      to = [];
+    } else if (!serialize && isErrorLike(from)) {
+      to = newError(from.name);
+    } else {
+      to = {};
+    }
+  }
+  seen.add(from);
+  if (depth >= maxDepth) {
+    seen.delete(from);
+    return to;
+  }
+  if (useToJSON && typeof from.toJSON === "function" && !toJsonWasCalled.has(from)) {
+    seen.delete(from);
+    return toJSON(from);
+  }
+  const continueDestroyCircular = (value) => destroyCircular({
+    from: value,
+    seen,
+    forceEnumerable,
+    maxDepth,
+    depth: depth + 1,
+    useToJSON,
+    serialize
+  });
+  for (const key of Object.keys(from)) {
+    const value = from[key];
+    if (value && value instanceof Uint8Array && value.constructor.name === "Buffer") {
+      to[key] = serialize ? "[object Buffer]" : value;
+      continue;
+    }
+    if (value !== null && typeof value === "object" && typeof value.pipe === "function") {
+      to[key] = serialize ? "[object Stream]" : value;
+      continue;
+    }
+    if (typeof value === "function") {
+      if (!serialize) {
+        to[key] = value;
+      }
+      continue;
+    }
+    if (serialize && typeof value === "bigint") {
+      to[key] = `${value}n`;
+      continue;
+    }
+    if (!value || typeof value !== "object") {
+      try {
+        to[key] = value;
+      } catch {
+      }
+      continue;
+    }
+    if (!seen.has(value)) {
+      to[key] = continueDestroyCircular(value);
+      continue;
+    }
+    to[key] = "[Circular]";
+  }
+  if (serialize || to instanceof Error) {
+    for (const { property, enumerable } of errorProperties) {
+      const value = from[property];
+      if (value === void 0 || value === null) {
+        continue;
+      }
+      const descriptor = Object.getOwnPropertyDescriptor(to, property);
+      if (descriptor?.configurable === false) {
+        continue;
+      }
+      let processedValue = value;
+      if (typeof value === "object") {
+        processedValue = seen.has(value) ? "[Circular]" : continueDestroyCircular(value);
+      }
+      Object.defineProperty(to, property, {
+        value: processedValue,
+        enumerable: forceEnumerable || enumerable,
+        configurable: true,
+        writable: true
+      });
+    }
+  }
+  seen.delete(from);
+  return to;
+};
+function serializeError(value, options = {}) {
+  const {
+    maxDepth = Number.POSITIVE_INFINITY,
+    useToJSON = true
+  } = options;
+  if (typeof value === "object" && value !== null) {
+    return destroyCircular({
+      from: value,
+      seen: /* @__PURE__ */ new Set(),
+      forceEnumerable: true,
+      maxDepth,
+      depth: 0,
+      useToJSON,
+      serialize: true
+    });
+  }
+  if (typeof value === "function") {
+    value = "<Function>";
+  }
+  return destroyCircular({
+    from: new NonError(value),
+    seen: /* @__PURE__ */ new Set(),
+    forceEnumerable: true,
+    maxDepth,
+    depth: 0,
+    useToJSON,
+    serialize: true
+  });
+}
+function isErrorLike(value) {
+  return Boolean(value) && typeof value === "object" && typeof value.name === "string" && typeof value.message === "string" && typeof value.stack === "string";
+}
+
+// src/index.ts
+var RELEASE_ID = typeof __MOONWATCH_RELEASE__ !== "undefined" ? __MOONWATCH_RELEASE__ : void 0;
+var LEVEL_ORDER = {
+  DEBUG: 0,
+  INFO: 1,
+  WARN: 2,
+  ERROR: 3,
+  FATAL: 4
+};
+var SDK_VERSION = "0.1.4";
+var DEFAULT_BASE_URL = "https://log.terodato.com";
+var BATCH_SIZE = 50;
+var MAX_BUFFER_SIZE = 1e3;
+var FLUSH_INTERVAL_MS = 1e3;
+var FETCH_TIMEOUT_MS = 1e4;
+var batchCounter = 0;
+var generateBatchId = () => `${Date.now()}-${++batchCounter}`;
+var originalConsole = {
+  log: console.log.bind(console),
+  info: console.info.bind(console),
+  warn: console.warn.bind(console),
+  error: console.error.bind(console),
+  debug: console.debug.bind(console)
+};
+function resolveLevel(level) {
+  if (!level) return "DEBUG";
+  if (level in LEVEL_ORDER) return level;
+  return "INFO";
+}
+function safeStringify(value) {
+  try {
+    return JSON.stringify(value);
+  } catch {
+    const seen = /* @__PURE__ */ new WeakSet();
+    return JSON.stringify(value, (_key, val) => {
+      if (typeof val === "object" && val !== null) {
+        if (seen.has(val)) return "[Circular]";
+        seen.add(val);
+      }
+      return val;
+    });
+  }
+}
+var _Logger = class _Logger {
+  constructor(config) {
+    this.buffer = [];
+    this.flushTimer = null;
+    this.flushPromise = null;
+    this.consoleIntercepted = false;
+    this.httpBackoffMs = 0;
+    this.maxBackoffMs = 6e4;
+    this.consecutiveHttpFailures = 0;
+    // Error capture via window event listeners (no console.error wrapping to
+    // avoid polluting stack traces shown in Next.js / React error overlays)
+    this._onError = null;
+    this._onUnhandledRejection = null;
+    // WebSocket state
+    this.ws = null;
+    this.wsState = "disconnected";
+    this.wsReconnectTimer = null;
+    this.wsReconnectAttempts = 0;
+    this.maxWsReconnectAttempts = 5;
+    // Browser lifecycle hooks for best-effort flush on page unload
+    this._onVisibilityChange = null;
+    this._onBeforeUnload = null;
+    this.config = {
+      logId: config.logId,
+      apiKey: config.apiKey,
+      group: config.group,
+      level: resolveLevel(config.level),
+      onError: config.onError,
+      traceId: config.traceId,
+      silent: config.silent ?? false,
+      debug: config.debug ?? false
+    };
+    this.proxyMode = !!config._ingestUrl;
+    const baseUrl = config._endpoint ?? DEFAULT_BASE_URL;
+    this.baseUrl = baseUrl;
+    const wsBaseUrl = config._wsEndpoint ?? baseUrl;
+    this.httpIngestUrl = config._ingestUrl ?? `${baseUrl}/ingest/http`;
+    this.wsIngestUrl = `${wsBaseUrl.replace(/^http/, "ws")}/ingest/ws`;
+    this.startFlushTimer();
+    if (!this.proxyMode && typeof WebSocket !== "undefined") {
+      this.connectWebSocket();
+    } else if (this.proxyMode) {
+      this.debugLog("Proxy mode enabled, using HTTP transport only");
+    } else {
+      this.debugLog("WebSocket not available, using HTTP transport only");
+    }
+    this.registerLifecycleHooks();
+  }
+  debugLog(msg, ...args) {
+    if (this.config.debug) {
+      originalConsole.debug("[Moonwatch]", msg, ...args);
+    }
+  }
+  connectWebSocket() {
+    if (this.wsState === "connecting" || this.wsState === "connected") {
+      return;
+    }
+    this.wsState = "connecting";
+    this.debugLog("WebSocket connecting to", this.wsIngestUrl);
+    try {
+      this.ws = new WebSocket(this.wsIngestUrl, ["api_key", this.config.apiKey]);
+      this.ws.onopen = () => {
+        this.wsReconnectAttempts = 0;
+        this.wsState = "connected";
+        this.debugLog("WebSocket connected");
+      };
+      this.ws.onmessage = (event) => {
+        try {
+          const msg = JSON.parse(event.data);
+          if (!msg.success) {
+            originalConsole.error("[Moonwatch] WebSocket log ingestion failed:", msg.error);
+          }
+        } catch {
+        }
+      };
+      this.ws.onerror = () => {
+      };
+      this.ws.onclose = () => {
+        this.wsState = "disconnected";
+        this.ws = null;
+        if (this.wsReconnectAttempts < this.maxWsReconnectAttempts) {
+          const delay = Math.min(1e3 * Math.pow(2, this.wsReconnectAttempts), 3e4);
+          this.wsReconnectAttempts++;
+          this.debugLog(`WebSocket disconnected, reconnecting in ${delay}ms (attempt ${this.wsReconnectAttempts}/${this.maxWsReconnectAttempts})`);
+          this.wsReconnectTimer = setTimeout(() => this.connectWebSocket(), delay);
+        } else {
+          this.debugLog("WebSocket max reconnect attempts reached, using HTTP only");
+        }
+      };
+    } catch {
+      this.wsState = "failed";
+      this.debugLog("WebSocket connection failed");
+    }
+  }
+  startFlushTimer() {
+    if (this.flushTimer) {
+      clearInterval(this.flushTimer);
+    }
+    this.flushTimer = setInterval(() => {
+      this.flush();
+    }, FLUSH_INTERVAL_MS);
+  }
+  shouldLog(level) {
+    return LEVEL_ORDER[level] >= LEVEL_ORDER[this.config.level];
+  }
+  formatArgs(args) {
+    return args.map((arg) => {
+      if (typeof arg === "string") return arg;
+      if (arg instanceof Error) return `${arg.message}
+${arg.stack}`;
+      try {
+        return JSON.stringify(arg, null, 2);
+      } catch {
+        return String(arg);
+      }
+    }).join(" ");
+  }
+  log(level, message, options) {
+    if (!this.shouldLog(level)) return;
+    if (!this.config.silent) {
+      const method = _Logger.CONSOLE_METHOD[level];
+      const consoleArgs = [message];
+      if (options?.metadata && Object.keys(options.metadata).length > 0) {
+        consoleArgs.push(options.metadata);
+      }
+      if (options?.stack) {
+        consoleArgs.push("\n" + options.stack);
+      }
+      originalConsole[method](...consoleArgs);
+    }
+    const entry = {
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      level,
+      message,
+      logId: this.config.logId,
+      group: options?.group ?? this.config.group,
+      trace_id: options?.traceId ?? this.config.traceId,
+      stack: options?.stack,
+      error_type: options?.errorType,
+      release_id: RELEASE_ID,
+      watcher_id: options?.watcherId,
+      metadata: options?.metadata
+    };
+    this.buffer.push(entry);
+    if (this.buffer.length > MAX_BUFFER_SIZE) {
+      const dropped = this.buffer.length - MAX_BUFFER_SIZE;
+      this.buffer.splice(0, dropped);
+      this.debugLog(`Buffer full, dropped ${dropped} oldest logs`);
+    }
+    if (this.buffer.length >= BATCH_SIZE) {
+      this.flush();
+    }
+  }
+  parseArgs(msgOrObj, metadata) {
+    if (typeof msgOrObj === "object") {
+      return {
+        message: msgOrObj.message,
+        options: { traceId: msgOrObj.traceId, group: msgOrObj.group, watcherId: msgOrObj.watcherId, metadata: msgOrObj.metadata }
+      };
+    }
+    if (metadata !== void 0) {
+      return { message: msgOrObj, options: { metadata } };
+    }
+    return { message: msgOrObj };
+  }
+  debug(msgOrObj, metadata) {
+    const { message, options } = this.parseArgs(msgOrObj, metadata);
+    this.log("DEBUG", message, options);
+  }
+  info(msgOrObj, metadata) {
+    const { message, options } = this.parseArgs(msgOrObj, metadata);
+    this.log("INFO", message, options);
+  }
+  warn(msgOrObj, metadata) {
+    const { message, options } = this.parseArgs(msgOrObj, metadata);
+    this.log("WARN", message, options);
+  }
+  error(msgOrObj, metadata) {
+    if (msgOrObj instanceof Error) {
+      this.log("ERROR", msgOrObj.message, {
+        metadata,
+        stack: msgOrObj.stack,
+        errorType: msgOrObj.name
+      });
+      return;
+    }
+    const { message, options } = this.parseArgs(msgOrObj, metadata);
+    this.log("ERROR", message, options);
+  }
+  fatal(msgOrObj, metadata) {
+    if (msgOrObj instanceof Error) {
+      this.log("FATAL", msgOrObj.message, {
+        metadata,
+        stack: msgOrObj.stack,
+        errorType: msgOrObj.name
+      });
+      return;
+    }
+    const { message, options } = this.parseArgs(msgOrObj, metadata);
+    this.log("FATAL", message, options);
+  }
+  withTraceId(traceId) {
+    return new ScopedLogger(this, void 0, traceId, void 0);
+  }
+  withGroup(group) {
+    return new ScopedLogger(this, group, void 0, void 0);
+  }
+  withWatcher(watcherId) {
+    return new ScopedLogger(this, void 0, void 0, watcherId);
+  }
+  setTraceId(traceId) {
+    this.config.traceId = traceId;
+  }
+  setGroup(group) {
+    this.config.group = group;
+  }
+  interceptConsole(group, options) {
+    if (this.consoleIntercepted) return;
+    this.consoleIntercepted = true;
+    const self = this;
+    const logGroup = group ?? "console";
+    const wrap = (original, level) => {
+      const wrapped = (...args) => {
+        let stack;
+        let errorType;
+        if (level === "ERROR") {
+          const errArg = args.find((a) => isErrorLike(a));
+          if (errArg) {
+            const serialized = serializeError(errArg);
+            stack = serialized.stack;
+            errorType = serialized.name;
+          } else {
+            const lines = new Error().stack?.split("\n");
+            if (lines) {
+              const isV8 = lines[0]?.trimStart().startsWith("Error");
+              stack = lines.slice(isV8 ? 2 : 1).join("\n");
+            }
+          }
+        }
+        queueMicrotask(() => {
+          self.log(level, self.formatArgs(args), { group: logGroup, stack, errorType });
+        });
+        return original.apply(console, args);
+      };
+      Object.defineProperty(wrapped, "name", { value: original.name });
+      return wrapped;
+    };
+    console.debug = wrap(originalConsole.debug, "DEBUG");
+    console.log = wrap(originalConsole.log, "INFO");
+    console.info = wrap(originalConsole.info, "INFO");
+    console.warn = wrap(originalConsole.warn, "WARN");
+    if (options?.wrapErrors !== false) {
+      console.error = wrap(originalConsole.error, "ERROR");
+    }
+    if (typeof window !== "undefined") {
+      this._onError = (event) => {
+        self.log("ERROR", event.message, {
+          group: logGroup,
+          stack: event.error?.stack,
+          errorType: event.error?.name
+        });
+      };
+      this._onUnhandledRejection = (event) => {
+        const err = event.reason;
+        const message = err instanceof Error ? err.message : String(err);
+        self.log("ERROR", message, {
+          group: logGroup,
+          stack: err instanceof Error ? err.stack : void 0,
+          errorType: err instanceof Error ? err.name : "UnhandledRejection"
+        });
+      };
+      window.addEventListener("error", this._onError);
+      window.addEventListener("unhandledrejection", this._onUnhandledRejection);
+    }
+  }
+  restoreConsole() {
+    if (!this.consoleIntercepted) return;
+    this.consoleIntercepted = false;
+    console.debug = originalConsole.debug;
+    console.log = originalConsole.log;
+    console.info = originalConsole.info;
+    console.warn = originalConsole.warn;
+    if (console.error !== originalConsole.error) {
+      console.error = originalConsole.error;
+    }
+    if (typeof window !== "undefined") {
+      if (this._onError) {
+        window.removeEventListener("error", this._onError);
+        this._onError = null;
+      }
+      if (this._onUnhandledRejection) {
+        window.removeEventListener("unhandledrejection", this._onUnhandledRejection);
+        this._onUnhandledRejection = null;
+      }
+    }
+  }
+  async flush() {
+    if (this.flushPromise) {
+      await this.flushPromise;
+    }
+    if (this.buffer.length === 0) return;
+    const logs = this.buffer.splice(0, this.buffer.length);
+    this.flushPromise = this.doFlush(logs);
+    try {
+      await this.flushPromise;
+    } finally {
+      this.flushPromise = null;
+    }
+  }
+  async doFlush(logs) {
+    const batchId = generateBatchId();
+    if (this.wsState === "connected" && typeof WebSocket !== "undefined") {
+      const sent = this.sendViaWebSocket(logs, batchId);
+      if (sent) return;
+    }
+    await this.sendViaHttp(logs, batchId);
+  }
+  sendViaWebSocket(logs, batchId) {
+    if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
+      return false;
+    }
+    try {
+      this.ws.send(safeStringify({ type: "logs", batchId, logs }));
+      this.debugLog(`Flushed ${logs.length} logs via WebSocket (batch ${batchId})`);
+      return true;
+    } catch {
+      this.debugLog("WebSocket send failed, falling back to HTTP");
+      return false;
+    }
+  }
+  async sendViaHttp(logs, batchId) {
+    if (this.httpBackoffMs > 0) {
+      await new Promise((resolve) => setTimeout(resolve, this.httpBackoffMs));
+    }
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), FETCH_TIMEOUT_MS);
+    try {
+      const headers = {
+        "Content-Type": "application/json",
+        "X-Batch-Id": batchId,
+        "X-SDK-Version": SDK_VERSION
+      };
+      if (this.config.apiKey) {
+        headers["Authorization"] = `Bearer ${this.config.apiKey}`;
+      }
+      const response = await fetch(this.httpIngestUrl, {
+        method: "POST",
+        headers,
+        body: safeStringify(logs),
+        signal: controller.signal
+      });
+      if (!response.ok) {
+        const error = await response.json().catch(() => ({ error: "Unknown error" }));
+        throw new Error(error.error || `HTTP ${response.status}`);
+      }
+      this.httpBackoffMs = 0;
+      this.consecutiveHttpFailures = 0;
+      this.debugLog(`Flushed ${logs.length} logs via HTTP (batch ${batchId})`);
+    } catch (err) {
+      this.buffer.unshift(...logs);
+      this.consecutiveHttpFailures++;
+      this.httpBackoffMs = Math.min(
+        Math.pow(2, this.consecutiveHttpFailures - 1) * 1e3,
+        this.maxBackoffMs
+      );
+      this.debugLog(`HTTP flush failed (retry in ${this.httpBackoffMs / 1e3}s):`, err);
+      if (this.config.onError) {
+        this.config.onError(err, logs);
+      } else {
+        originalConsole.error(
+          `[Moonwatch] Failed to flush logs (retry in ${this.httpBackoffMs / 1e3}s):`,
+          err
+        );
+      }
+    } finally {
+      clearTimeout(timeout);
+    }
+  }
+  /** Fire-and-forget flush using fetch with keepalive (works during page unload) */
+  flushSync() {
+    if (this.buffer.length === 0) return;
+    const logs = this.buffer.splice(0, this.buffer.length);
+    try {
+      const headers = {
+        "Content-Type": "application/json",
+        "X-Batch-Id": generateBatchId(),
+        "X-SDK-Version": SDK_VERSION
+      };
+      if (this.config.apiKey) {
+        headers["Authorization"] = `Bearer ${this.config.apiKey}`;
+      }
+      fetch(this.httpIngestUrl, {
+        method: "POST",
+        headers,
+        body: safeStringify(logs),
+        keepalive: true
+      });
+    } catch {
+    }
+  }
+  registerLifecycleHooks() {
+    if (typeof window !== "undefined") {
+      this._onVisibilityChange = () => {
+        if (document.visibilityState === "hidden") {
+          this.flushSync();
+        }
+      };
+      document.addEventListener("visibilitychange", this._onVisibilityChange);
+      this._onBeforeUnload = () => {
+        this.flushSync();
+      };
+      window.addEventListener("beforeunload", this._onBeforeUnload);
+    }
+  }
+  /** Check server connectivity and API key validity */
+  async ping() {
+    const start = Date.now();
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), FETCH_TIMEOUT_MS);
+    try {
+      const headers = {};
+      if (this.config.apiKey) {
+        headers["Authorization"] = `Bearer ${this.config.apiKey}`;
+      }
+      const response = await fetch(`${this.baseUrl}/health`, {
+        headers,
+        signal: controller.signal
+      });
+      const latencyMs = Date.now() - start;
+      if (!response.ok) {
+        const body = await response.json().catch(() => ({ error: `HTTP ${response.status}` }));
+        return { ok: false, latencyMs, error: body.error || `HTTP ${response.status}` };
+      }
+      return { ok: true, latencyMs };
+    } catch (err) {
+      return { ok: false, latencyMs: Date.now() - start, error: err.message };
+    } finally {
+      clearTimeout(timeout);
+    }
+  }
+  /** Get current connection status */
+  getConnectionStatus() {
+    if (this.wsState === "connected") {
+      return { transport: "websocket", state: "connected" };
+    }
+    return { transport: "http", state: "connected" };
+  }
+};
+_Logger.CONSOLE_METHOD = {
+  DEBUG: "debug",
+  INFO: "info",
+  WARN: "warn",
+  ERROR: "error",
+  FATAL: "error"
+};
+var Logger = _Logger;
+var ScopedLogger = class _ScopedLogger {
+  constructor(parent, group, traceId, watcherId) {
+    this.parent = parent;
+    this.group = group;
+    this.traceId = traceId;
+    this.watcherId = watcherId;
+  }
+  withGroup(group) {
+    return new _ScopedLogger(this.parent, group, this.traceId, this.watcherId);
+  }
+  withTraceId(traceId) {
+    return new _ScopedLogger(this.parent, this.group, traceId, this.watcherId);
+  }
+  withWatcher(watcherId) {
+    return new _ScopedLogger(this.parent, this.group, this.traceId, watcherId);
+  }
+  opts(message, metadata) {
+    return {
+      message,
+      ...this.group && { group: this.group },
+      ...this.traceId && { traceId: this.traceId },
+      ...this.watcherId && { watcherId: this.watcherId },
+      ...metadata && { metadata }
+    };
+  }
+  debug(message, metadata) {
+    this.parent.debug(this.opts(message, metadata));
+  }
+  info(message, metadata) {
+    this.parent.info(this.opts(message, metadata));
+  }
+  warn(message, metadata) {
+    this.parent.warn(this.opts(message, metadata));
+  }
+  error(message, metadata) {
+    this.parent.error(this.opts(message, metadata));
+  }
+  fatal(message, metadata) {
+    this.parent.fatal(this.opts(message, metadata));
+  }
+};
+function createLogger(config) {
+  return new Logger(config);
+}
+var index_default = createLogger;
+export {
+  Logger,
+  createLogger,
+  index_default as default
+};