@aeres/farol-web 0.0.0-stage → 0.2.0

package/dist/index.js

@@ -0,0 +1,1273 @@
+const REDACTED = "[REDACTED]";
+const sensitiveKey = /(?:authorization|cookie|password|passwd|secret|token|api[-_]?key|credential|session[-_]?id|private[-_]?key)/i;
+const isSensitiveKey = (key) => sensitiveKey.test(key);
+function redactUrl(value) {
+  try {
+    const url = new URL(value, "http://farol.invalid");
+    if (url.username) url.username = REDACTED;
+    if (url.password) url.password = REDACTED;
+    for (const key of [...url.searchParams.keys()])
+      if (isSensitiveKey(key)) url.searchParams.set(key, REDACTED);
+    if (url.hash && /(?:token|password|secret|api[-_]?key|code)=/i.test(url.hash))
+      url.hash = REDACTED;
+    const result = url.toString();
+    return result.startsWith("http://farol.invalid") ? `${url.pathname}${url.search}${url.hash}` : result;
+  } catch {
+    return value.replace(
+      /([?&](?:[^=&]*(?:token|password|secret|api[-_]?key)[^=&]*)=)[^&#\s]*/gi,
+      `$1${REDACTED}`
+    );
+  }
+}
+function redactText(value, max) {
+  let text = value;
+  if (text.length <= 65536 && /^[\s]*[\[{]/.test(text)) {
+    try {
+      const encoded = JSON.stringify(
+        safeSerialize(JSON.parse(text), { maxString: max })
+      );
+      return encoded.length > max ? `${encoded.slice(0, max)}…[truncated]` : encoded;
+    } catch {
+    }
+  }
+  text = text.replace(
+    /\b(?:https?|wss?):\/\/[^\s"'<>]+/gi,
+    (url) => redactUrl(url)
+  );
+  if (/^(?:\/|[a-z][a-z\d+.-]*:\/\/)/i.test(text)) text = redactUrl(text);
+  text = text.replace(/\b(Bearer|Basic)\s+[A-Za-z\d+/_=.-]+/gi, `$1 ${REDACTED}`).replace(
+    /((?:(?:password|passwd|secret|token|api[-_]?key|authorization|cookie)[\w-]{0,40})["']?\s*[:=]\s*["']?)[^\s,"'&;}]+/gi,
+    `$1${REDACTED}`
+  );
+  return text.length > max ? `${text.slice(0, max)}…[truncated]` : text;
+}
+function safeSerialize(value, limits = {}) {
+  const depthLimit = limits.maxDepth ?? 6;
+  const entriesLimit = limits.maxEntries ?? 80;
+  const stringLimit = limits.maxString ?? 4096;
+  const seen = /* @__PURE__ */ new WeakSet();
+  let budget = 600;
+  function visit(item, depth, key = "") {
+    if (isSensitiveKey(key)) return REDACTED;
+    if (budget-- <= 0) return "[Truncated]";
+    if (item === null || typeof item === "boolean" || typeof item === "number")
+      return typeof item === "number" && !Number.isFinite(item) ? String(item) : item;
+    if (typeof item === "string") return redactText(item, stringLimit);
+    if (typeof item === "bigint") return `${item}n`;
+    if (typeof item === "undefined") return "[undefined]";
+    if (typeof item === "function")
+      return `[Function ${item.name || "anonymous"}]`;
+    if (typeof item === "symbol") return String(item);
+    if (depth >= depthLimit) return "[Max depth]";
+    const obj = item;
+    if (seen.has(obj)) return "[Circular]";
+    seen.add(obj);
+    if (obj instanceof Error)
+      return {
+        name: obj.name,
+        message: redactText(obj.message, stringLimit),
+        stack: obj.stack ? redactText(obj.stack, stringLimit) : void 0,
+        ..."cause" in obj ? { cause: visit(obj.cause, depth + 1) } : {}
+      };
+    if (obj instanceof Date)
+      return Number.isFinite(obj.getTime()) ? obj.toISOString() : "Invalid Date";
+    if (typeof URL !== "undefined" && obj instanceof URL)
+      return redactUrl(obj.href);
+    if (typeof Headers !== "undefined" && obj instanceof Headers)
+      return visit(Object.fromEntries(obj.entries()), depth + 1);
+    if (typeof Element !== "undefined" && obj instanceof Element)
+      return `<${obj.tagName.toLowerCase()}${obj.id ? `#${obj.id}` : ""}>`;
+    if (typeof Blob !== "undefined" && obj instanceof Blob)
+      return `[Blob ${obj.type || "binary"}; ${obj.size} bytes]`;
+    if (obj instanceof Map) {
+      const entries = [];
+      for (const [mapKey, mapValue] of obj) {
+        if (entries.length >= entriesLimit) break;
+        entries.push([
+          visit(mapKey, depth + 1),
+          visit(mapValue, depth + 1, typeof mapKey === "string" ? mapKey : "")
+        ]);
+      }
+      if (obj.size > entriesLimit)
+        entries.push(`[${obj.size - entriesLimit} more items]`);
+      return entries;
+    }
+    if (obj instanceof Set) {
+      const items = [];
+      for (const value2 of obj) {
+        if (items.length >= entriesLimit) break;
+        items.push(visit(value2, depth + 1));
+      }
+      if (obj.size > entriesLimit)
+        items.push(`[${obj.size - entriesLimit} more items]`);
+      return items;
+    }
+    if (ArrayBuffer.isView(obj))
+      return `[${obj.constructor.name}; ${obj.byteLength} bytes]`;
+    if (Array.isArray(obj))
+      return obj.slice(0, entriesLimit).map((child) => visit(child, depth + 1)).concat(
+        obj.length > entriesLimit ? [`[${obj.length - entriesLimit} more items]`] : []
+      );
+    const result = {};
+    let descriptors;
+    try {
+      descriptors = Object.getOwnPropertyDescriptors(obj);
+    } catch {
+      return "[Uninspectable]";
+    }
+    const keys = Object.keys(descriptors).filter(
+      (k) => descriptors[k].enumerable
+    );
+    for (const property of keys.slice(0, entriesLimit)) {
+      const desc = descriptors[property];
+      Object.defineProperty(result, property, {
+        value: isSensitiveKey(property) ? REDACTED : "value" in desc ? visit(desc.value, depth + 1, property) : "[Getter]",
+        enumerable: true,
+        configurable: true,
+        writable: true
+      });
+    }
+    if (keys.length > entriesLimit)
+      result["…"] = `${keys.length - entriesLimit} more keys`;
+    return result;
+  }
+  try {
+    return visit(value, 0);
+  } catch {
+    return "[Unserializable]";
+  }
+}
+const serializationMarker = /\[(?:REDACTED|Max depth|Circular|Truncated(?:[^\]]*)?|undefined|Uninspectable|Unserializable|Getter|Function(?:[^\]]*)|Blob(?:[^\]]*)|(?:[A-Za-z]\w*Array|DataView); \d+ bytes|\d+ more items|Body (?:omitted|unavailable)(?:[^\]]*))\]/i;
+function containsSerializationMarkers(value) {
+  const seen = /* @__PURE__ */ new WeakSet();
+  let budget = 1e4;
+  function check(item, depth) {
+    if (budget-- <= 0 || depth > 40) return true;
+    if (typeof item === "string") {
+      if (serializationMarker.test(item) || /%5b(?:REDACTED|Max%20depth|Circular|Truncated)%5d/i.test(item))
+        return true;
+      if (/^(?:NaN|[+-]?Infinity|-?\d+n|Symbol\([^)]*\)|<[^<> ]+>)$/.test(item))
+        return true;
+      if (/^\s*[\[{]/.test(item) && item.length <= 65536) {
+        try {
+          return check(JSON.parse(item), depth + 1);
+        } catch {
+        }
+      }
+      return false;
+    }
+    if (item === null || typeof item === "boolean") return false;
+    if (typeof item === "number") return !Number.isFinite(item);
+    if (typeof item !== "object") return true;
+    if (seen.has(item)) return true;
+    seen.add(item);
+    if (Array.isArray(item))
+      return item.some((entry) => check(entry, depth + 1));
+    let descriptors;
+    try {
+      descriptors = Object.getOwnPropertyDescriptors(item);
+    } catch {
+      return true;
+    }
+    for (const [key, descriptor] of Object.entries(descriptors)) {
+      if (!descriptor.enumerable) continue;
+      if (key === "…" || key === "truncated" && descriptor.value === true)
+        return true;
+      if (!("value" in descriptor) || check(descriptor.value, depth + 1))
+        return true;
+    }
+    return false;
+  }
+  try {
+    return check(value, 0);
+  } catch {
+    return true;
+  }
+}
+const textContent = /(?:json|text|xml|javascript|x-www-form-urlencoded)/i;
+const now = () => typeof performance !== "undefined" ? performance.now() : Date.now();
+function matchMock(rules, url, method) {
+  for (const rule of rules.values()) {
+    if (rule.method !== "*" && rule.method.toUpperCase() !== method.toUpperCase())
+      continue;
+    const expression = `^${rule.url.split("*").map((p) => p.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")).join(".*")}$`;
+    try {
+      if (new RegExp(expression).test(url) || new RegExp(expression).test(new URL(url).pathname))
+        return rule;
+    } catch {
+    }
+  }
+  return void 0;
+}
+async function readBody(stream, headers, max) {
+  if (!stream) return void 0;
+  const contentType = headers.get("content-type") || "";
+  if (!textContent.test(contentType) || /event-stream/i.test(contentType)) {
+    void stream.cancel().catch(() => {
+    });
+    return "[Body omitted: non-text or streaming content]";
+  }
+  const length = Number(headers.get("content-length"));
+  if (length > max) {
+    void stream.cancel().catch(() => {
+    });
+    return `[Body omitted: ${length} bytes]`;
+  }
+  const reader = stream.getReader();
+  const decoder = new TextDecoder();
+  let size = 0;
+  let text = "";
+  try {
+    while (true) {
+      const chunk = await reader.read();
+      if (chunk.done) break;
+      size += chunk.value.byteLength;
+      if (size > max) {
+        void reader.cancel().catch(() => {
+        });
+        return "[Body omitted: size limit]";
+      }
+      text += decoder.decode(chunk.value, { stream: true });
+    }
+    text += decoder.decode();
+    if (/json/i.test(contentType)) {
+      try {
+        return JSON.parse(text);
+      } catch {
+      }
+    }
+    return text;
+  } catch {
+    return "[Body unavailable]";
+  } finally {
+    try {
+      reader.releaseLock();
+    } catch {
+    }
+  }
+}
+function requestBody(input, init, max) {
+  if (init?.body != null) {
+    if (typeof init.body === "string")
+      return Promise.resolve(
+        new TextEncoder().encode(init.body).length <= max ? init.body : "[Body omitted: size limit]"
+      );
+    if (init.body instanceof URLSearchParams)
+      return Promise.resolve(Object.fromEntries(init.body.entries()));
+    if (typeof FormData !== "undefined" && init.body instanceof FormData)
+      return Promise.resolve("[Body omitted: multipart data]");
+    return Promise.resolve("[Body omitted: binary/stream content]");
+  }
+  if (typeof Request !== "undefined" && input instanceof Request) {
+    try {
+      const clone = input.clone();
+      return readBody(clone.body, clone.headers, max);
+    } catch {
+      return Promise.resolve("[Body unavailable]");
+    }
+  }
+  return Promise.resolve(void 0);
+}
+function mockBody(rule) {
+  if (rule.status === 204 || rule.status === 205 || rule.status === 304)
+    return null;
+  return typeof rule.body === "string" ? rule.body : JSON.stringify(rule.body ?? null);
+}
+function instrumentNetwork(ctx) {
+  const { win, controls } = ctx;
+  let stopped = false;
+  const cleanups = /* @__PURE__ */ new Set();
+  const collector = new URL(ctx.endpoint);
+  collector.protocol = collector.protocol === "wss:" ? "https:" : "http:";
+  const internalPaths = /* @__PURE__ */ new Set([
+    collector.pathname,
+    "/ws",
+    "/rn",
+    "/api/config",
+    "/api/demo/config",
+    "/api/health"
+  ]);
+  const excluded = (url) => {
+    try {
+      const u = new URL(url, win.location.href);
+      return u.origin === collector.origin && internalPaths.has(u.pathname);
+    } catch {
+      return false;
+    }
+  };
+  const emit = (data) => {
+    if (!stopped) ctx.emit(data);
+  };
+  const wait = (ms, signal) => new Promise((resolve, reject) => {
+    if (signal?.aborted) {
+      reject(signal.reason ?? new DOMException("Aborted", "AbortError"));
+      return;
+    }
+    const done = () => {
+      clearTimeout(timer);
+      signal?.removeEventListener("abort", abort);
+      cleanups.delete(cancel);
+      resolve();
+    };
+    const abort = () => {
+      clearTimeout(timer);
+      signal?.removeEventListener("abort", abort);
+      cleanups.delete(cancel);
+      reject(signal?.reason ?? new DOMException("Aborted", "AbortError"));
+    };
+    const timer = setTimeout(done, ms);
+    const cancel = () => done();
+    cleanups.add(cancel);
+    signal?.addEventListener("abort", abort, { once: true });
+  });
+  const originalFetch = win.fetch;
+  if (typeof originalFetch === "function") {
+    const wrapped = async function(input, init) {
+      const rawUrl = typeof input === "string" ? input : input instanceof URL ? input.href : input.url;
+      let url;
+      try {
+        url = new URL(rawUrl, win.location.href).href;
+      } catch {
+        return originalFetch.call(win, input, init);
+      }
+      if (excluded(url) || stopped) return originalFetch.call(win, input, init);
+      const req = typeof Request !== "undefined" && input instanceof Request ? input : void 0;
+      const method = (init?.method || req?.method || "GET").toUpperCase();
+      const headers = new Headers(init?.headers ?? req?.headers);
+      const start = now();
+      const rule = matchMock(controls.mocks, url, method);
+      const signal = init?.signal ?? req?.signal;
+      const body = ctx.captureBodies ? requestBody(input, init, ctx.maxBodyBytes) : Promise.resolve(void 0);
+      const base = {
+        method,
+        url,
+        requestHeaders: Object.fromEntries(headers.entries()),
+        mocked: Boolean(rule)
+      };
+      try {
+        if (controls.latency > 0 || (rule?.delay ?? 0) > 0)
+          await wait(controls.latency + (rule?.delay ?? 0), signal);
+        if (!stopped && controls.offline)
+          throw new TypeError("Farol: simulated offline network");
+        if (signal?.aborted)
+          throw signal.reason ?? new DOMException("Aborted", "AbortError");
+        const response = !stopped && rule ? new Response(mockBody(rule), {
+          status: rule.status,
+          headers: {
+            "content-type": typeof rule.body === "string" ? "text/plain" : "application/json",
+            "x-farol-mock": rule.id
+          }
+        }) : await originalFetch.call(win, input, init);
+        const duration = now() - start;
+        const responseHeaders = Object.fromEntries(response.headers.entries());
+        let responseBody = Promise.resolve(void 0);
+        if (ctx.captureBodies) {
+          try {
+            const clone = response.clone();
+            responseBody = readBody(
+              clone.body,
+              clone.headers,
+              ctx.maxBodyBytes
+            );
+          } catch {
+            responseBody = Promise.resolve("[Body unavailable]");
+          }
+        }
+        void Promise.all([body, responseBody]).then(
+          ([requestBody2, responseBody2]) => emit({
+            ...base,
+            status: response.status,
+            duration,
+            responseHeaders,
+            ...ctx.captureBodies ? { requestBody: requestBody2, responseBody: responseBody2 } : {}
+          })
+        ).catch(() => {
+        });
+        return response;
+      } catch (error) {
+        void body.then(
+          (requestBody2) => emit({
+            ...base,
+            status: 0,
+            duration: now() - start,
+            error: error instanceof Error ? error.message : String(error),
+            ...ctx.captureBodies ? { requestBody: requestBody2 } : {}
+          })
+        ).catch(() => {
+        });
+        throw error;
+      }
+    };
+    win.fetch = wrapped;
+    cleanups.add(() => {
+      if (win.fetch === wrapped) win.fetch = originalFetch;
+    });
+  }
+  if (typeof win.XMLHttpRequest === "function") {
+    let restoreOverrides = function(xhr) {
+      const request = requests.get(xhr);
+      for (const key of request?.overrides ?? []) {
+        try {
+          delete xhr[key];
+        } catch {
+        }
+      }
+      if (request) request.overrides = [];
+      const ref = refsByRequest.get(xhr);
+      if (ref) {
+        mockRefs.delete(ref);
+        finalizer.unregister(ref);
+        refsByRequest.delete(xhr);
+      }
+    };
+    const proto = win.XMLHttpRequest.prototype;
+    const originalOpen = proto.open;
+    const originalSend = proto.send;
+    const originalSetHeader = proto.setRequestHeader;
+    const originalAbort = proto.abort;
+    const requests = /* @__PURE__ */ new WeakMap();
+    const mockRefs = /* @__PURE__ */ new Set();
+    const refsByRequest = /* @__PURE__ */ new WeakMap();
+    const finalizer = new FinalizationRegistry(
+      (ref) => mockRefs.delete(ref)
+    );
+    cleanups.add(() => {
+      for (const ref of mockRefs) {
+        const xhr = ref.deref();
+        if (xhr) restoreOverrides(xhr);
+        else finalizer.unregister(ref);
+      }
+      mockRefs.clear();
+    });
+    const open = function(method, url, ...rest) {
+      const previous = requests.get(this);
+      previous?.cancel?.();
+      restoreOverrides(this);
+      requests.set(this, {
+        method: method.toUpperCase(),
+        url: new URL(String(url), win.location.href).href,
+        headers: {}
+      });
+      return originalOpen.call(this, method, url, ...rest);
+    };
+    const setHeader = function(key, value) {
+      const request = requests.get(this);
+      const result = originalSetHeader.call(this, key, value);
+      if (request) request.headers[key] = value;
+      return result;
+    };
+    const send = function(body) {
+      const request = requests.get(this);
+      if (!request || excluded(request.url) || stopped)
+        return originalSend.call(this, body);
+      const start = now();
+      const xhr = this;
+      const rule = matchMock(controls.mocks, request.url, request.method);
+      let completed = false;
+      const finish = () => {
+        if (completed) return;
+        completed = true;
+        xhr.removeEventListener("loadend", finish);
+        cleanups.delete(removeListener);
+        let responseHeaders = {};
+        let responseBody;
+        try {
+          responseHeaders = Object.fromEntries(
+            xhr.getAllResponseHeaders().trim().split(/[\r\n]+/).filter(Boolean).map((h) => {
+              const i = h.indexOf(":");
+              return [h.slice(0, i).trim(), h.slice(i + 1).trim()];
+            })
+          );
+        } catch {
+        }
+        if (ctx.captureBodies) {
+          try {
+            responseBody = xhr.responseType === "json" ? xhr.response : !xhr.responseType || xhr.responseType === "text" ? xhr.responseText.length <= ctx.maxBodyBytes ? xhr.responseText : "[Body omitted: size limit]" : "[Body omitted: binary content]";
+          } catch {
+            responseBody = "[Body unavailable]";
+          }
+        }
+        const requestBody2 = typeof body === "string" ? body.length <= ctx.maxBodyBytes ? body : "[Body omitted: size limit]" : body == null ? void 0 : "[Body omitted: non-text content]";
+        emit({
+          method: request.method,
+          url: request.url,
+          status: xhr.status,
+          duration: now() - start,
+          requestHeaders: request.headers,
+          responseHeaders,
+          mocked: Boolean(rule),
+          ...xhr.status === 0 ? { error: "XHR failed, aborted, or simulated offline" } : {},
+          ...ctx.captureBodies ? { requestBody: requestBody2, responseBody } : {}
+        });
+      };
+      const removeListener = () => xhr.removeEventListener("loadend", finish);
+      xhr.addEventListener("loadend", finish, { once: true });
+      cleanups.add(removeListener);
+      request.finish = finish;
+      const dispatch = (name) => xhr.dispatchEvent(new Event(name));
+      const simulate = () => {
+        const offline = controls.offline;
+        if (!offline && !rule) {
+          originalSend.call(xhr, body);
+          return;
+        }
+        const content = rule ? mockBody(rule) ?? "" : "";
+        const values = {
+          readyState: 4,
+          status: offline ? 0 : rule.status,
+          statusText: offline ? "" : "Farol Mock",
+          responseURL: request.url,
+          responseText: content,
+          response: xhr.responseType === "json" ? rule?.body : content,
+          getAllResponseHeaders: () => "content-type: application/json\r\n",
+          getResponseHeader: (name) => name.toLowerCase() === "content-type" ? "application/json" : null
+        };
+        request.overrides = Object.keys(values);
+        const ref = new WeakRef(xhr);
+        mockRefs.add(ref);
+        refsByRequest.set(xhr, ref);
+        finalizer.register(xhr, ref, ref);
+        for (const [key, value] of Object.entries(values))
+          Object.defineProperty(xhr, key, { configurable: true, value });
+        dispatch("readystatechange");
+        dispatch(offline ? "error" : "load");
+        dispatch("loadend");
+      };
+      const simulated = controls.offline || Boolean(rule);
+      const latency = controls.latency + (rule?.delay ?? 0);
+      if (!simulated && latency === 0) {
+        try {
+          return originalSend.call(xhr, body);
+        } catch (error) {
+          finish();
+          throw error;
+        }
+      }
+      const timer = setTimeout(() => {
+        cleanups.delete(cancel);
+        request.cancel = void 0;
+        if (stopped) originalSend.call(xhr, body);
+        else simulate();
+      }, latency);
+      const cancel = () => {
+        clearTimeout(timer);
+        cleanups.delete(cancel);
+        request.cancel = void 0;
+        if (stopped && !completed) {
+          try {
+            originalSend.call(xhr, body);
+          } catch {
+          }
+        }
+      };
+      request.cancel = cancel;
+      cleanups.add(cancel);
+      dispatch("loadstart");
+    };
+    const abort = function() {
+      const request = requests.get(this);
+      if (request?.cancel) {
+        request.cancel();
+        this.dispatchEvent(new Event("abort"));
+        this.dispatchEvent(new Event("loadend"));
+      }
+      return originalAbort.call(this);
+    };
+    proto.open = open;
+    proto.send = send;
+    proto.setRequestHeader = setHeader;
+    proto.abort = abort;
+    cleanups.add(() => {
+      if (proto.open === open) proto.open = originalOpen;
+      if (proto.send === send) proto.send = originalSend;
+      if (proto.setRequestHeader === setHeader)
+        proto.setRequestHeader = originalSetHeader;
+      if (proto.abort === abort) proto.abort = originalAbort;
+    });
+  }
+  return () => {
+    stopped = true;
+    for (const cleanup of [...cleanups]) {
+      try {
+        cleanup();
+      } catch {
+      }
+    }
+    cleanups.clear();
+  };
+}
+const SDK_VERSION = "0.2.0";
+const SINGLETON = /* @__PURE__ */ Symbol.for("aeres.farol.web.client");
+const NOOP = () => {
+};
+function inactive() {
+  return {
+    enabled: false,
+    connected: false,
+    session: null,
+    getSession: () => null,
+    track: NOOP,
+    record: NOOP,
+    watchStore: () => NOOP,
+    observeQueryClient: () => NOOP,
+    destroy: NOOP
+  };
+}
+const uid = () => globalThis.crypto?.randomUUID?.() ?? `${Date.now().toString(36)}-${Math.random().toString(36).slice(2)}`;
+const clamp = (value, fallback, max) => typeof value === "number" && Number.isFinite(value) ? Math.min(Math.max(Math.floor(value), 0), max) : fallback;
+function initFarol(options) {
+  if (typeof window === "undefined" || typeof document === "undefined")
+    return inactive();
+  const win = window;
+  const global = win;
+  global[SINGLETON]?.destroy();
+  if (options?.enabled !== true || !options.token?.trim() || typeof win.WebSocket !== "function")
+    return inactive();
+  let endpoint;
+  try {
+    endpoint = new URL(options.endpoint ?? "ws://127.0.0.1:4318/ws");
+  } catch {
+    return inactive();
+  }
+  if (!["ws:", "wss:"].includes(endpoint.protocol) || !["localhost", "127.0.0.1", "[::1]"].includes(endpoint.hostname) || endpoint.username || endpoint.password)
+    return inactive();
+  const session = {
+    platform: "web",
+    runtime: "browser",
+    id: uid(),
+    appName: String(options.appName || "React app").slice(0, 120),
+    url: redactUrl(win.location.href),
+    userAgent: win.navigator.userAgent,
+    startedAt: Date.now(),
+    sdkVersion: SDK_VERSION
+  };
+  const cleanups = /* @__PURE__ */ new Set();
+  const stores = /* @__PURE__ */ new Map();
+  const queryClients = /* @__PURE__ */ new Set();
+  const queue = [];
+  const maxQueue = clamp(options.maxQueueSize, 400, 2e3);
+  const controls = {
+    offline: false,
+    latency: 0,
+    mocks: /* @__PURE__ */ new Map()
+  };
+  let stopped = false;
+  let ready = false;
+  let socket = null;
+  let reconnectTimer;
+  let flushTimer;
+  let attempt = 0;
+  let highlighted = null;
+  let highlightTimer;
+  let executingCommand = false;
+  function flushQueue() {
+    if (flushTimer) {
+      clearTimeout(flushTimer);
+      flushTimer = void 0;
+    }
+    if (stopped || !ready || socket?.readyState !== 1) return;
+    while (queue.length && socket.bufferedAmount < 1048576) {
+      try {
+        socket.send(queue.shift());
+      } catch {
+        break;
+      }
+    }
+    if (queue.length) flushTimer = setTimeout(flushQueue, 100);
+  }
+  function send(message, buffer = true) {
+    if (stopped) return;
+    let serialized = JSON.stringify(message);
+    if (new TextEncoder().encode(serialized).byteLength > 65536) {
+      const result = message;
+      if (result.type !== "command.result") return;
+      serialized = JSON.stringify({
+        type: "command.result",
+        id: result.id,
+        sessionId: result.sessionId,
+        ok: false,
+        error: "Resultado excede o limite de 64 KiB após redação. Reduza o volume de dados consultados."
+      });
+    }
+    if (ready && socket?.readyState === 1 && socket.bufferedAmount < 1048576) {
+      try {
+        socket.send(serialized);
+        return;
+      } catch {
+      }
+    }
+    if (buffer && maxQueue > 0) {
+      queue.push(serialized);
+      if (queue.length > maxQueue) queue.splice(0, queue.length - maxQueue);
+      if (ready && !flushTimer) flushTimer = setTimeout(flushQueue, 100);
+    }
+  }
+  function record(kind, name, data, level) {
+    if (stopped) return;
+    try {
+      const safe = safeSerialize(data);
+      const event = {
+        id: uid(),
+        sessionId: session.id,
+        timestamp: Date.now(),
+        kind,
+        name: String(safeSerialize(name, { maxString: 200 })),
+        data: safe,
+        ...level ? { level } : {},
+        ...typeof data.duration === "number" ? { duration: data.duration } : {}
+      };
+      if (new TextEncoder().encode(JSON.stringify(event)).byteLength > 6e4)
+        event.data = {
+          truncated: true,
+          message: "Event exceeded 60 KB after redaction"
+        };
+      send({ type: "event", event });
+    } catch {
+    }
+  }
+  const listen = (target, type, handler) => {
+    target.addEventListener(type, handler);
+    cleanups.add(() => target.removeEventListener(type, handler));
+  };
+  function getStorage(area) {
+    if (area !== "local" && area !== "session")
+      throw new Error("area must be local or session");
+    return area === "local" ? win.localStorage : win.sessionStorage;
+  }
+  function storageSnapshot() {
+    const result = {
+      local: {},
+      session: {}
+    };
+    for (const area of ["local", "session"]) {
+      try {
+        const storage = getStorage(area);
+        for (let i = 0; i < Math.min(storage.length, 100); i++) {
+          const key = storage.key(i);
+          if (key != null)
+            Object.defineProperty(result[area], key, {
+              value: isSensitiveKey(key) ? REDACTED : safeSerialize(storage.getItem(key)),
+              enumerable: true
+            });
+        }
+      } catch {
+        result[area] = { unavailable: "Storage is blocked by browser policy" };
+      }
+    }
+    return result;
+  }
+  function clearHighlight() {
+    if (highlightTimer) clearTimeout(highlightTimer);
+    highlighted?.remove();
+    highlighted = null;
+  }
+  function domSnapshot() {
+    return Array.from(
+      document.body?.querySelectorAll(
+        "main,section,article,header,nav,h1,h2,h3,p,button,a,input,select,textarea,[role]"
+      ) ?? []
+    ).filter((element) => element !== highlighted).slice(0, 150).map((element) => ({
+      tag: element.tagName.toLowerCase(),
+      id: element.id,
+      role: element.getAttribute("role"),
+      // Text excludes controls and editable/private content; no input values or data-* attributes.
+      text: element.matches(
+        "input,select,textarea,[contenteditable], [data-farol-private], [data-private]"
+      ) || element.closest(
+        "[data-farol-private],[data-private],[contenteditable]"
+      ) ? "[private]" : Array.from(element.childNodes).filter((node) => node.nodeType === 3).map((node) => node.textContent).join(" ").trim().slice(0, 160),
+      rect: (() => {
+        const rect = element.getBoundingClientRect();
+        return {
+          x: Math.round(rect.x),
+          y: Math.round(rect.y),
+          width: Math.round(rect.width),
+          height: Math.round(rect.height)
+        };
+      })()
+    }));
+  }
+  async function execute(command) {
+    const args = command.args ?? {};
+    switch (command.name) {
+      case "storage.list":
+        return storageSnapshot();
+      case "storage.set": {
+        if (typeof args.key !== "string" || typeof args.value !== "string" || args.key.length > 512 || args.value.length > 16384)
+          throw new Error("Invalid storage key/value");
+        if (containsSerializationMarkers(args.value))
+          throw new Error(
+            "Valor contém marcadores de redação ou truncamento. Informe um valor completo para evitar sobrescrever dados reais."
+          );
+        getStorage(args.area).setItem(args.key, args.value);
+        return { area: args.area, key: args.key, updated: true };
+      }
+      case "storage.remove": {
+        if (typeof args.key !== "string")
+          throw new Error("Invalid storage key");
+        getStorage(args.area).removeItem(args.key);
+        return { area: args.area, key: args.key, removed: true };
+      }
+      case "state.set": {
+        const store = stores.get(String(args.store));
+        if (!store?.setState) throw new Error("Store does not expose setState");
+        if (containsSerializationMarkers(args.value))
+          throw new Error(
+            "Estado contém marcadores de redação ou truncamento. Snapshots incompletos não podem substituir dados reais."
+          );
+        store.setState(args.value);
+        return { store: args.store, state: store.getState() };
+      }
+      case "query.invalidate": {
+        if (args.queryKey !== void 0 && !Array.isArray(args.queryKey))
+          throw new Error("queryKey must be an array");
+        if (!queryClients.size) throw new Error("No QueryClient registered");
+        await Promise.all(
+          [...queryClients].map(
+            (client2) => Promise.resolve(
+              client2.invalidateQueries(
+                args.queryKey ? { queryKey: args.queryKey } : void 0
+              )
+            )
+          )
+        );
+        return { invalidated: true };
+      }
+      case "network.get":
+        return {
+          offline: controls.offline,
+          latency: controls.latency,
+          mocks: [...controls.mocks.values()]
+        };
+      case "network.configure": {
+        if (typeof args.offline === "boolean") controls.offline = args.offline;
+        if (args.latency !== void 0)
+          controls.latency = clamp(args.latency, 0, 3e4);
+        record("custom", "Network simulation configured", {
+          ...controls,
+          mocks: controls.mocks.size
+        });
+        return { offline: controls.offline, latency: controls.latency };
+      }
+      case "mock.set": {
+        if (typeof args.id !== "string" || !args.id || typeof args.url !== "string" || !args.url || args.url.length > 512 || typeof args.method !== "string")
+          throw new Error("Mock requires id, url and method");
+        const status = Number(args.status ?? 200);
+        if (!Number.isInteger(status) || status < 200 || status > 599)
+          throw new Error("Mock status must be between 200 and 599");
+        if (controls.mocks.size >= 50 && !controls.mocks.has(args.id))
+          throw new Error("Maximum 50 mocks");
+        const rule = {
+          id: args.id.slice(0, 100),
+          url: args.url,
+          method: args.method.toUpperCase(),
+          status,
+          body: args.body,
+          delay: clamp(args.delay, 0, 3e4)
+        };
+        controls.mocks.set(rule.id, rule);
+        return rule;
+      }
+      case "mock.remove":
+        return { removed: controls.mocks.delete(String(args.id)) };
+      case "dom.snapshot":
+        return { elements: domSnapshot() };
+      case "dom.highlight": {
+        if (typeof args.selector !== "string" || args.selector.length > 512)
+          throw new Error("Invalid selector");
+        const target = document.querySelector(args.selector);
+        if (!target) throw new Error("Element not found");
+        clearHighlight();
+        const rect = target.getBoundingClientRect();
+        highlighted = document.createElement("div");
+        highlighted.setAttribute("data-farol-highlight", "");
+        highlighted.style.cssText = `position:fixed;pointer-events:none;z-index:2147483647;border:2px solid #27c9a8;background:rgba(39,201,168,.12);left:${rect.left}px;top:${rect.top}px;width:${rect.width}px;height:${rect.height}px;box-sizing:border-box;`;
+        document.body.appendChild(highlighted);
+        highlightTimer = setTimeout(clearHighlight, 3e3);
+        return { highlighted: args.selector };
+      }
+      case "page.reload":
+        setTimeout(() => {
+          if (!stopped) win.location.reload();
+        }, 80);
+        return { reloading: true };
+      case "nav.go": {
+        if (typeof args.url !== "string") throw new Error("Invalid URL");
+        const url = new URL(args.url, win.location.href);
+        if (url.origin !== win.location.origin || !["http:", "https:"].includes(url.protocol) || url.username || url.password)
+          throw new Error("Navigation must stay on the same origin");
+        win.history.pushState(null, "", url.href);
+        win.dispatchEvent(new PopStateEvent("popstate"));
+        return { url: redactUrl(url.href) };
+      }
+      default:
+        throw new Error(`Unsupported command: ${command.name}`);
+    }
+  }
+  function connect() {
+    if (stopped) return;
+    try {
+      socket = new win.WebSocket(endpoint.href);
+    } catch {
+      scheduleReconnect();
+      return;
+    }
+    const current = socket;
+    current.onopen = () => {
+      if (stopped) return;
+      current.send(
+        JSON.stringify({ type: "auth", role: "sdk", token: options.token })
+      );
+    };
+    current.onmessage = (message) => {
+      if (stopped || current !== socket || typeof message.data !== "string" || message.data.length > 65536)
+        return;
+      try {
+        const data = JSON.parse(message.data);
+        if (data.type === "ready") {
+          ready = true;
+          attempt = 0;
+          send({ type: "hello", session });
+          flushQueue();
+          return;
+        }
+        if (data.type !== "command" || !ready || data.sessionId !== session.id || typeof data.id !== "string" || data.id.length > 128 || typeof data.name !== "string" || data.name.length > 100)
+          return;
+        if (executingCommand) {
+          send(
+            {
+              type: "command.result",
+              id: data.id,
+              sessionId: session.id,
+              ok: false,
+              error: "Another command is running"
+            },
+            false
+          );
+          return;
+        }
+        executingCommand = true;
+        void execute(data).then(
+          (result) => {
+            send(
+              {
+                type: "command.result",
+                id: data.id,
+                sessionId: session.id,
+                ok: true,
+                data: safeSerialize(result)
+              },
+              false
+            );
+          },
+          (error) => {
+            send(
+              {
+                type: "command.result",
+                id: data.id,
+                sessionId: session.id,
+                ok: false,
+                error: String(
+                  safeSerialize(
+                    error instanceof Error ? error.message : String(error)
+                  )
+                )
+              },
+              false
+            );
+          }
+        ).finally(() => {
+          executingCommand = false;
+        });
+      } catch {
+      }
+    };
+    current.onclose = (event) => {
+      if (current !== socket) return;
+      ready = false;
+      if (!stopped && event.code !== 1008) scheduleReconnect();
+    };
+    current.onerror = NOOP;
+  }
+  function scheduleReconnect() {
+    if (stopped || reconnectTimer) return;
+    reconnectTimer = setTimeout(
+      () => {
+        reconnectTimer = void 0;
+        connect();
+      },
+      Math.min(500 * 2 ** attempt++, 15e3) + Math.random() * 250
+    );
+  }
+  const client = {
+    enabled: true,
+    get connected() {
+      return ready && !stopped;
+    },
+    session,
+    getSession: () => session,
+    record,
+    track: (name, data = {}) => record("custom", name, data),
+    watchStore(name, adapter) {
+      if (stopped) return NOOP;
+      const key = String(name).slice(0, 120);
+      stores.set(key, adapter);
+      const emit = () => {
+        try {
+          record("state", key, { store: key, state: adapter.getState() });
+        } catch (error) {
+          record("error", "Store inspection failed", { store: key, error });
+        }
+      };
+      emit();
+      let unsubscribe;
+      try {
+        unsubscribe = adapter.subscribe(emit);
+      } catch (error) {
+        record("error", "Store subscription failed", { store: key, error });
+      }
+      const cleanup = () => {
+        try {
+          unsubscribe?.();
+        } catch {
+        }
+        if (stores.get(key) === adapter) stores.delete(key);
+        cleanups.delete(cleanup);
+      };
+      cleanups.add(cleanup);
+      return cleanup;
+    },
+    observeQueryClient(queryClient) {
+      if (stopped) return NOOP;
+      queryClients.add(queryClient);
+      const emit = (query) => record("query", "Query cache", {
+        queryKey: query.queryKey,
+        state: query.state
+      });
+      let unsubscribe;
+      try {
+        const cache = queryClient.getQueryCache();
+        cache.getAll().slice(0, 100).forEach(emit);
+        unsubscribe = cache.subscribe((event) => {
+          if (event?.query) emit(event.query);
+        });
+      } catch (error) {
+        record("error", "Query inspection failed", { error });
+      }
+      const cleanup = () => {
+        try {
+          unsubscribe?.();
+        } catch {
+        }
+        queryClients.delete(queryClient);
+        cleanups.delete(cleanup);
+      };
+      cleanups.add(cleanup);
+      return cleanup;
+    },
+    destroy() {
+      if (stopped) return;
+      stopped = true;
+      ready = false;
+      if (reconnectTimer) clearTimeout(reconnectTimer);
+      if (flushTimer) clearTimeout(flushTimer);
+      clearHighlight();
+      for (const cleanup of [...cleanups]) {
+        try {
+          cleanup();
+        } catch {
+        }
+      }
+      cleanups.clear();
+      stores.clear();
+      queryClients.clear();
+      controls.mocks.clear();
+      queue.length = 0;
+      if (socket) {
+        socket.onopen = socket.onmessage = socket.onclose = socket.onerror = null;
+        socket.close(1e3, "Farol stopped");
+        socket = null;
+      }
+      if (global[SINGLETON] === client) delete global[SINGLETON];
+    }
+  };
+  global[SINGLETON] = client;
+  for (const level of ["debug", "log", "info", "warn", "error"]) {
+    const original = win.console[level];
+    const wrapped = (...args) => {
+      original.apply(win.console, args);
+      record("console", level, { args }, level === "log" ? "info" : level);
+    };
+    win.console[level] = wrapped;
+    cleanups.add(() => {
+      if (win.console[level] === wrapped) win.console[level] = original;
+    });
+  }
+  listen(win, "error", ((event) => record(
+    "error",
+    event.message || "Resource error",
+    {
+      error: event.error,
+      message: event.message,
+      filename: event.filename,
+      line: event.lineno,
+      column: event.colno
+    },
+    "error"
+  )));
+  listen(win, "unhandledrejection", ((event) => record(
+    "error",
+    "Unhandled promise rejection",
+    { reason: event.reason },
+    "error"
+  )));
+  try {
+    cleanups.add(
+      instrumentNetwork({
+        win,
+        endpoint: endpoint.href,
+        controls,
+        captureBodies: options.captureBodies === true,
+        maxBodyBytes: clamp(options.maxBodyBytes, 8192, 32768),
+        emit: (data) => record(
+          "network",
+          `${data.method} ${redactUrl(String(data.url))}`,
+          data,
+          data.error || Number(data.status) >= 400 ? "error" : "info"
+        )
+      })
+    );
+  } catch (error) {
+    record("error", "Network instrumentation unavailable", { error });
+  }
+  try {
+    const prototype = win.Storage.prototype;
+    for (const operation of ["setItem", "removeItem", "clear"]) {
+      const original = prototype[operation];
+      const wrapped = function(...args) {
+        const result = original.apply(this, args);
+        let area;
+        try {
+          area = this === win.localStorage ? "local" : this === win.sessionStorage ? "session" : void 0;
+        } catch {
+        }
+        if (area)
+          record("storage", `${area}.${operation}`, {
+            area,
+            key: args[0] ?? null,
+            value: args[0] && isSensitiveKey(args[0]) ? REDACTED : args[1],
+            action: operation
+          });
+        return result;
+      };
+      prototype[operation] = wrapped;
+      cleanups.add(() => {
+        if (prototype[operation] === wrapped)
+          prototype[operation] = original;
+      });
+    }
+    listen(win, "storage", ((event) => {
+      let area = "local";
+      try {
+        if (event.storageArea === win.sessionStorage) area = "session";
+      } catch {
+      }
+      record("storage", "Cross-tab storage change", {
+        area,
+        key: event.key,
+        value: event.key && isSensitiveKey(event.key) ? REDACTED : event.newValue,
+        action: event.key == null ? "clear" : event.newValue == null ? "removeItem" : "setItem"
+      });
+    }));
+    record("storage", "Storage snapshot", storageSnapshot());
+  } catch (error) {
+    record("storage", "Storage unavailable", { error });
+  }
+  const navigation = (action) => record("navigation", action, {
+    url: redactUrl(win.location.href),
+    title: document.title
+  });
+  for (const method of ["pushState", "replaceState"]) {
+    const original = win.history[method];
+    const wrapped = function(...args) {
+      const result = original.apply(win.history, args);
+      navigation(method);
+      return result;
+    };
+    win.history[method] = wrapped;
+    cleanups.add(() => {
+      if (win.history[method] === wrapped) win.history[method] = original;
+    });
+  }
+  listen(win, "popstate", () => navigation("popstate"));
+  listen(win, "hashchange", () => navigation("hashchange"));
+  navigation("initial");
+  if (typeof win.PerformanceObserver === "function") {
+    let cls = 0;
+    let windowStart = 0;
+    let lastShift = 0;
+    let windowValue = 0;
+    for (const type of [
+      "navigation",
+      "largest-contentful-paint",
+      "layout-shift",
+      "longtask",
+      "paint"
+    ]) {
+      if (!win.PerformanceObserver.supportedEntryTypes?.includes(type))
+        continue;
+      try {
+        const observer = new win.PerformanceObserver((list) => {
+          for (const entry of list.getEntries().slice(0, 50)) {
+            const item = entry;
+            if (type === "layout-shift") {
+              if (item.hadRecentInput) continue;
+              if (!lastShift || item.startTime - lastShift > 1e3 || item.startTime - windowStart > 5e3) {
+                windowStart = item.startTime;
+                windowValue = 0;
+              }
+              windowValue += item.value ?? 0;
+              lastShift = item.startTime;
+              cls = Math.max(cls, windowValue);
+              record("performance", "CLS", {
+                value: cls,
+                delta: item.value,
+                startTime: item.startTime
+              });
+            } else
+              record(
+                "performance",
+                type === "largest-contentful-paint" ? "LCP" : type,
+                {
+                  value: type === "largest-contentful-paint" ? item.renderTime || item.loadTime || item.startTime : item.duration || item.startTime,
+                  name: item.name,
+                  duration: item.duration,
+                  startTime: item.startTime,
+                  ...type === "navigation" ? {
+                    domContentLoaded: item.domContentLoadedEventEnd,
+                    load: item.loadEventEnd,
+                    ttfb: item.responseStart,
+                    transferSize: item.transferSize
+                  } : {}
+                }
+              );
+          }
+        });
+        observer.observe({ type, buffered: true });
+        cleanups.add(() => observer.disconnect());
+      } catch {
+      }
+    }
+  }
+  connect();
+  return client;
+}
+export {
+  REDACTED,
+  SDK_VERSION,
+  containsSerializationMarkers,
+  initFarol,
+  redactUrl,
+  safeSerialize
+};
+//# sourceMappingURL=index.js.map