veo-sdk 0.6.2 → 0.6.3

package/dist/index.d.cts

@@ -26,6 +26,11 @@ interface VeoAutocaptureConfig {
     captureElementMetadata?: boolean;
     /** Niveles de ancestros a capturar. Default: 5. Max: 10. */
     captureAncestors?: number;
+    /**
+     * Calidad de los clics: emite `$dead_click` (clic sin reacción), `$rage_click`
+     * (ráfaga de clics) y `$click_error` (clic seguido de un error). Default: true.
+     */
+    captureClickQuality?: boolean;
 }
 /**
  * Configuración del cliente Veo.

package/dist/index.d.ts

@@ -26,6 +26,11 @@ interface VeoAutocaptureConfig {
     captureElementMetadata?: boolean;
     /** Niveles de ancestros a capturar. Default: 5. Max: 10. */
     captureAncestors?: number;
+    /**
+     * Calidad de los clics: emite `$dead_click` (clic sin reacción), `$rage_click`
+     * (ráfaga de clics) y `$click_error` (clic seguido de un error). Default: true.
+     */
+    captureClickQuality?: boolean;
 }
 /**
  * Configuración del cliente Veo.

package/dist/index.mjs

@@ -1,7 +1,7 @@
-import { definePlugin, guidesPlugin, runPreviewMode } from './chunk-L3QQJLDJ.mjs';
-export { definePlugin, guidesPlugin } from './chunk-L3QQJLDJ.mjs';
-import { hasWindow, hasDocument, uuidv7, DEFAULT_AUTOCAPTURE_CONFIG, MAX_ANCESTORS, hasLocalStorage, hasNavigatorSendBeacon, isBuilderMode, ALWAYS_BLOCK_SELECTORS, buildSelectorPath, resolveBuilderToken, filterHumanClasses, PRIORITY_ATTRIBUTES, SENSITIVE_ATTRIBUTES, getPreviewToken, previewGuide, closeGuidePreview } from './chunk-ZILDR4YE.mjs';
-export { closeGuidePreview, previewGuide } from './chunk-ZILDR4YE.mjs';
+import { definePlugin, guidesPlugin, runPreviewMode } from './chunk-3JEAPZ6A.mjs';
+export { definePlugin, guidesPlugin } from './chunk-3JEAPZ6A.mjs';
+import { hasWindow, hasDocument, uuidv7, DEFAULT_AUTOCAPTURE_CONFIG, MAX_ANCESTORS, hasLocalStorage, hasNavigatorSendBeacon, isBuilderMode, buildSelectorPath, ALWAYS_BLOCK_SELECTORS, resolveBuilderToken, filterHumanClasses, PRIORITY_ATTRIBUTES, SENSITIVE_ATTRIBUTES, getPreviewToken, previewGuide, closeGuidePreview } from './chunk-SZCIXA5X.mjs';
+export { closeGuidePreview, previewGuide } from './chunk-SZCIXA5X.mjs';
 import './chunk-PTG3BTJE.mjs';
 
 // src/contract/v1.ts
@@ -62,6 +62,294 @@ function deriveBuilderUrl() {
   return null;
 }
 
+// src/plugins/autocapture/click-quality.ts
+var NO_DEAD_TAGS = /* @__PURE__ */ new Set(["input", "textarea", "select", "option", "label"]);
+var MAX_ERROR_MESSAGE = 200;
+var HISTORY_MS = 3e3;
+var DEFAULTS = {
+  reactionWindowMs: 1e3,
+  errorWindowMs: 2e3,
+  rageClicks: 3,
+  rageWindowMs: 1e3,
+  rageClicksSlow: 5,
+  rageWindowSlowMs: 3e3,
+  maxPerElement: 50
+};
+function describeError(value) {
+  let text;
+  if (value instanceof Error) text = `${value.name}: ${value.message}`;
+  else if (typeof value === "string") text = value;
+  else {
+    try {
+      text = JSON.stringify(value) ?? String(value);
+    } catch {
+      text = String(value);
+    }
+  }
+  return text.slice(0, MAX_ERROR_MESSAGE);
+}
+var ClickQualityTracker = class {
+  constructor(emit, options = {}) {
+    this.emit = emit;
+    this.installed = false;
+    this.cleanups = [];
+    // Sensores globales (contadores: cada observación compara su foto inicial).
+    this.netCount = 0;
+    this.navCount = 0;
+    this.focusCount = 0;
+    this.unloading = false;
+    this.errors = [];
+    this.history = /* @__PURE__ */ new Map();
+    this.bursts = /* @__PURE__ */ new Map();
+    this.emitted = /* @__PURE__ */ new Map();
+    this.opts = { ...DEFAULTS, ...options };
+  }
+  install() {
+    if (this.installed || !hasWindow()) return;
+    this.installed = true;
+    const on = (type, handler, capture = true) => {
+      window.addEventListener(type, handler, capture);
+      this.cleanups.push(() => window.removeEventListener(type, handler, capture));
+    };
+    on("error", (e) => {
+      const err = e;
+      this.pushError("error", err.error ?? err.message ?? "error");
+    });
+    on("unhandledrejection", (e) => {
+      this.pushError("unhandledrejection", e.reason ?? "rejection");
+    });
+    on("popstate", () => this.navCount++);
+    on("hashchange", () => this.navCount++);
+    on("focusin", () => this.focusCount++);
+    on("pagehide", () => {
+      this.unloading = true;
+    });
+    on("beforeunload", () => {
+      this.unloading = true;
+    });
+    this.patchHistory();
+    this.patchConsole();
+    this.patchFetch();
+    this.patchXhr();
+  }
+  destroy() {
+    for (const c of this.cleanups) c();
+    this.cleanups = [];
+    for (const b of this.bursts.values()) window.clearTimeout(b.timer);
+    this.bursts.clear();
+    this.history.clear();
+    this.installed = false;
+  }
+  /** Llamar por cada clic real sobre un elemento interactivo, ANTES del throttle. */
+  onClick(element, event) {
+    if (!this.installed) return;
+    const now = Date.now();
+    const obs = { at: now, reacted: false };
+    this.remember(element, obs);
+    this.observeReaction(element, obs, event);
+    this.observeErrors(element, now);
+    this.trackRage(element, now);
+  }
+  // ---------------------------------------------------------------- dead ----
+  observeReaction(element, obs, event) {
+    const netAtClick = this.netCount;
+    const navAtClick = this.navCount;
+    const focusAtClick = this.focusCount;
+    const hrefAtClick = window.location.href;
+    const skipDead = this.isDeadExempt(element, event);
+    let observer = null;
+    if (typeof MutationObserver !== "undefined") {
+      observer = new MutationObserver(() => {
+        obs.reacted = true;
+        observer?.disconnect();
+        observer = null;
+      });
+      observer.observe(document.documentElement, {
+        childList: true,
+        attributes: true,
+        characterData: true,
+        subtree: true
+      });
+    }
+    window.setTimeout(() => {
+      observer?.disconnect();
+      const reacted = obs.reacted || this.unloading || this.netCount !== netAtClick || this.navCount !== navAtClick || this.focusCount !== focusAtClick || window.location.href !== hrefAtClick;
+      obs.reacted = reacted;
+      if (!reacted && !skipDead) this.report("$dead_click", element, {});
+    }, this.opts.reactionWindowMs);
+  }
+  isDeadExempt(element, event) {
+    if (event && (event.ctrlKey || event.metaKey || event.shiftKey || event.altKey)) return true;
+    if (event && typeof event.button === "number" && event.button !== 0) return true;
+    const tag = element.tagName.toLowerCase();
+    if (NO_DEAD_TAGS.has(tag)) return true;
+    if (element.closest('[contenteditable=""],[contenteditable="true"]')) return true;
+    const anchor = element.closest("a");
+    if (anchor) {
+      if (anchor.target === "_blank" || anchor.hasAttribute("download")) return true;
+      const href = anchor.getAttribute("href") ?? "";
+      if (/^(mailto|tel|sms):/i.test(href)) return true;
+    }
+    return false;
+  }
+  // --------------------------------------------------------------- error ----
+  observeErrors(element, clickedAt) {
+    const deadline = clickedAt + this.opts.errorWindowMs;
+    const check = () => {
+      const err = this.errors.find((e) => e.at >= clickedAt && e.at <= deadline);
+      if (err) {
+        this.report("$click_error", element, {
+          $error_source: err.source,
+          $error_message: err.message
+        });
+        return;
+      }
+      if (Date.now() < deadline) window.setTimeout(check, 250);
+    };
+    window.setTimeout(check, 250);
+  }
+  pushError(source, value) {
+    const message = describeError(value);
+    if (message.startsWith("[veo]")) return;
+    this.errors.push({ at: Date.now(), source, message });
+    const cutoff = Date.now() - this.opts.errorWindowMs - 1e3;
+    while (this.errors.length > 0 && this.errors[0].at < cutoff) {
+      this.errors.shift();
+    }
+    if (this.errors.length > 50) this.errors.splice(0, this.errors.length - 50);
+  }
+  // ---------------------------------------------------------------- rage ----
+  remember(element, obs) {
+    const list = this.history.get(element) ?? [];
+    const cutoff = obs.at - HISTORY_MS;
+    const kept = list.filter((o) => o.at >= cutoff);
+    kept.push(obs);
+    this.history.set(element, kept);
+    if (this.history.size > 100) {
+      for (const [el, obsList] of this.history) {
+        if (obsList.every((o) => o.at < cutoff)) this.history.delete(el);
+      }
+    }
+  }
+  trackRage(element, now) {
+    const list = this.history.get(element) ?? [];
+    const fast = list.filter((o) => o.at >= now - this.opts.rageWindowMs).length;
+    const slow = list.filter((o) => o.at >= now - this.opts.rageWindowSlowMs).length;
+    const existing = this.bursts.get(element);
+    const isRage = fast >= this.opts.rageClicks || slow >= this.opts.rageClicksSlow;
+    if (!existing && !isRage) return;
+    const burst = existing ?? {
+      startedAt: (list.find((o) => o.at >= now - this.opts.rageWindowSlowMs) ?? { at: now }).at,
+      count: 0,
+      timer: 0
+    };
+    burst.count = list.filter((o) => o.at >= burst.startedAt).length;
+    window.clearTimeout(burst.timer);
+    burst.timer = window.setTimeout(() => {
+      this.bursts.delete(element);
+      const clicks = (this.history.get(element) ?? []).filter((o) => o.at >= burst.startedAt);
+      this.report("$rage_click", element, {
+        $click_count: Math.max(clicks.length, burst.count),
+        $reacted_clicks: clicks.filter((o) => o.reacted).length
+      });
+    }, this.opts.reactionWindowMs + 50);
+    this.bursts.set(element, burst);
+  }
+  // ---------------------------------------------------------------- emit ----
+  report(kind, element, extra) {
+    const key = buildSelectorPath(element, 5);
+    const counts = this.emitted.get(key) ?? { $dead_click: 0, $rage_click: 0, $click_error: 0 };
+    if (counts[kind] >= this.opts.maxPerElement) return;
+    counts[kind]++;
+    this.emitted.set(key, counts);
+    try {
+      this.emit(kind, element, extra);
+    } catch {
+    }
+  }
+  // ------------------------------------------------------------- patches ----
+  patchHistory() {
+    const h = window.history;
+    if (!h) return;
+    const origPush = h.pushState;
+    const origReplace = h.replaceState;
+    const self = this;
+    h.pushState = function(...args) {
+      self.navCount++;
+      return origPush.apply(this, args);
+    };
+    h.replaceState = function(...args) {
+      self.navCount++;
+      return origReplace.apply(this, args);
+    };
+    this.cleanups.push(() => {
+      h.pushState = origPush;
+      h.replaceState = origReplace;
+    });
+  }
+  patchConsole() {
+    const orig = console.error;
+    const self = this;
+    console.error = function(...args) {
+      try {
+        self.pushError("console", args.map(describeError).join(" "));
+      } catch {
+      }
+      return orig.apply(this, args);
+    };
+    this.cleanups.push(() => {
+      console.error = orig;
+    });
+  }
+  /**
+   * `fetch`: cuenta la petición (reacción) y registra respuestas ≥500 o
+   * rechazos como error. Se observa con `.then(ok, err)` sobre la promesa
+   * original: eso marca el rechazo como manejado para el navegador, así que
+   * un fetch fallido sin catch de la app no dispara `unhandledrejection` —
+   * lo registramos nosotros como error de red.
+   */
+  patchFetch() {
+    if (typeof window.fetch !== "function") return;
+    const orig = window.fetch;
+    const self = this;
+    window.fetch = function(...args) {
+      self.netCount++;
+      const p = orig.apply(this, args);
+      if (p && typeof p.then === "function") {
+        p.then(
+          (res) => {
+            if (res && res.status >= 500) self.pushError("fetch", `${res.status} ${res.url}`);
+          },
+          (err) => self.pushError("fetch", err)
+        );
+      }
+      return p;
+    };
+    this.cleanups.push(() => {
+      window.fetch = orig;
+    });
+  }
+  patchXhr() {
+    const proto = typeof XMLHttpRequest !== "undefined" ? XMLHttpRequest.prototype : null;
+    if (!proto) return;
+    const origSend = proto.send;
+    const self = this;
+    proto.send = function(...args) {
+      self.netCount++;
+      try {
+        this.addEventListener("loadend", () => {
+          if (this.status >= 500) self.pushError("xhr", `${this.status} ${this.responseURL}`);
+        });
+      } catch {
+      }
+      return origSend.apply(this, args);
+    };
+    this.cleanups.push(() => {
+      proto.send = origSend;
+    });
+  }
+};
+
 // src/plugins/autocapture/pii-guard.ts
 function isElementBlocked(element, extraBlockSelectors = []) {
   const allBlockers = [...ALWAYS_BLOCK_SELECTORS, ...extraBlockSelectors];
@@ -165,6 +453,7 @@ var DomListener = class {
   constructor(client, config) {
     this.client = client;
     this.cleanups = [];
+    this.quality = null;
     const d = DEFAULT_AUTOCAPTURE_CONFIG;
     this.config = {
       enabled: config.enabled ?? d.enabled,
@@ -177,12 +466,20 @@ var DomListener = class {
       throttleMs: config.throttleMs ?? d.throttleMs,
       maxTextLength: config.maxTextLength ?? d.maxTextLength,
       captureElementMetadata: config.captureElementMetadata ?? d.captureElementMetadata,
-      captureAncestors: Math.min(config.captureAncestors ?? d.captureAncestors, MAX_ANCESTORS)
+      captureAncestors: Math.min(config.captureAncestors ?? d.captureAncestors, MAX_ANCESTORS),
+      captureClickQuality: config.captureClickQuality ?? d.captureClickQuality
     };
     this.throttle = new ElementThrottle(this.config.throttleMs);
   }
   install() {
     if (!hasDocument() || !this.config.enabled) return;
+    if (this.config.captureClicks && this.config.captureClickQuality) {
+      this.quality = new ClickQualityTracker((kind, element, extra) => {
+        const payload = buildAutocapturePayload("click", element, this.config);
+        this.client.track(kind, { ...payload, ...extra });
+      });
+      this.quality.install();
+    }
     if (this.config.captureClicks) this.attach("click", (e) => this.handleClick(e));
     if (this.config.captureSubmits) this.attach("submit", (e) => this.handleSubmit(e), true);
     if (this.config.captureChanges) this.attach("change", (e) => this.handleChange(e), true);
@@ -190,6 +487,8 @@ var DomListener = class {
   destroy() {
     for (const cleanup of this.cleanups) cleanup();
     this.cleanups = [];
+    this.quality?.destroy();
+    this.quality = null;
   }
   attach(eventName, handler, useCapture = false) {
     const listener = (e) => {
@@ -208,6 +507,7 @@ var DomListener = class {
     const meaningful = this.findMeaningfulAncestor(target);
     if (!meaningful) return;
     if (isElementBlocked(meaningful, this.config.blockSelectors)) return;
+    this.quality?.onClick(meaningful, event);
     if (!this.throttle.shouldFire(meaningful)) return;
     this.emit("click", meaningful);
   }
@@ -966,7 +1266,7 @@ function init(config) {
     // Fallback de carga del builder para bundlers: `import()` dinámico → el bundler
     // lo code-splitea (solo se descarga en modo builder). Así el consumidor por
     // bundler NO necesita copiar `veo-builder.js` ni setear `builderUrl`.
-    () => import('./builder-ENKEIVF2.mjs').then((m) => m.initBuilderMode()),
+    () => import('./builder-PPLIAUCM.mjs').then((m) => m.initBuilderMode()),
     // Detector de tema: también por `import()` dinámico → chunk aparte que el
     // bundler solo descarga cuando toca detectar (como mucho una vez al día).
     () => import('./detect-theme-X4K3TLUL.mjs')