veo-sdk 0.6.1 → 0.6.3

package/dist/index.d.cts

@@ -1,4 +1,4 @@
-export { P as PreviewGuideInput, a as PreviewHandle, b as PreviewResult, c as closeGuidePreview, p as previewGuide } from './guide-preview-DylsEhrg.cjs';
+export { P as PreviewGuideInput, a as PreviewHandle, b as PreviewResult, c as closeGuidePreview, p as previewGuide } from './guide-preview-DEFhfA4o.cjs';
 
 /**
  * Configuración de la autocaptura de interacciones del DOM.
@@ -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.
@@ -49,6 +54,18 @@ interface VeoConfig {
      * tooltips. Default: `false`.
      */
     guides?: boolean;
+    /**
+     * Detectar el tema visual de la app (colores base en claro/oscuro y fuentes)
+     * para que el design system de OnUser arranque con la marca del cliente.
+     * Solo viajan colores y nombres de fuentes, como mucho una vez al día por
+     * navegador. Default: `true`; `false` lo deshabilita.
+     */
+    detectTheme?: boolean;
+    /**
+     * URL del bundle del detector de tema (`veo-theme.js`). Solo aplica al build
+     * IIFE; si se omite, se deriva del `<script>` que cargó `veo.js`.
+     */
+    themeUrl?: string;
     /**
      * URL del bundle del builder (`veo-builder.js`). Solo se carga cuando la
      * página trae `?veoBuilder=<token>` (modo edición desde el dashboard). Si

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-export { P as PreviewGuideInput, a as PreviewHandle, b as PreviewResult, c as closeGuidePreview, p as previewGuide } from './guide-preview-DylsEhrg.js';
+export { P as PreviewGuideInput, a as PreviewHandle, b as PreviewResult, c as closeGuidePreview, p as previewGuide } from './guide-preview-DEFhfA4o.js';
 
 /**
  * Configuración de la autocaptura de interacciones del DOM.
@@ -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.
@@ -49,6 +54,18 @@ interface VeoConfig {
      * tooltips. Default: `false`.
      */
     guides?: boolean;
+    /**
+     * Detectar el tema visual de la app (colores base en claro/oscuro y fuentes)
+     * para que el design system de OnUser arranque con la marca del cliente.
+     * Solo viajan colores y nombres de fuentes, como mucho una vez al día por
+     * navegador. Default: `true`; `false` lo deshabilita.
+     */
+    detectTheme?: boolean;
+    /**
+     * URL del bundle del detector de tema (`veo-theme.js`). Solo aplica al build
+     * IIFE; si se omite, se deriva del `<script>` que cargó `veo.js`.
+     */
+    themeUrl?: string;
     /**
      * URL del bundle del builder (`veo-builder.js`). Solo se carga cuando la
      * página trae `?veoBuilder=<token>` (modo edición desde el dashboard). Si

package/dist/index.mjs

@@ -1,7 +1,7 @@
-import { definePlugin, guidesPlugin, runPreviewMode } from './chunk-GVPAJFNW.mjs';
-export { definePlugin, guidesPlugin } from './chunk-GVPAJFNW.mjs';
-import { hasWindow, hasDocument, uuidv7, DEFAULT_AUTOCAPTURE_CONFIG, MAX_ANCESTORS, hasLocalStorage, hasNavigatorSendBeacon, ALWAYS_BLOCK_SELECTORS, buildSelectorPath, resolveBuilderToken, filterHumanClasses, PRIORITY_ATTRIBUTES, SENSITIVE_ATTRIBUTES, getPreviewToken, isBuilderMode, previewGuide, closeGuidePreview } from './chunk-NGP7IJVE.mjs';
-export { closeGuidePreview, previewGuide } from './chunk-NGP7IJVE.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);
   }
@@ -291,6 +591,118 @@ function spaRouterPlugin() {
   });
 }
 
+// src/plugins/theme-detect/index.ts
+var STORAGE_PREFIX = "veo_theme_";
+var RESEND_AFTER_MS = 24 * 60 * 60 * 1e3;
+var SETTLE_MS = 4e3;
+var MAX_RUNS_PER_PAGE = 4;
+function readState(key) {
+  try {
+    const raw = localStorage.getItem(key);
+    const parsed = raw ? JSON.parse(raw) : null;
+    return parsed && typeof parsed === "object" ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+function writeState(key, state) {
+  try {
+    localStorage.setItem(key, JSON.stringify(state));
+  } catch {
+  }
+}
+function guessMode(doc, prefersDark) {
+  const hints = [
+    doc.documentElement.className,
+    doc.documentElement.dataset.theme,
+    doc.documentElement.dataset.mode,
+    doc.body?.className
+  ].join(" ").toLowerCase();
+  if (/\bdark\b/.test(hints)) return "dark";
+  if (/\blight\b/.test(hints)) return "light";
+  return prefersDark ? "dark" : "light";
+}
+function isFresh(state, mode, now) {
+  const last = state[mode];
+  return last !== void 0 && now - last.at < RESEND_AFTER_MS;
+}
+function shouldSendSnapshot(state, mode, hash, now) {
+  const last = state[mode];
+  return !last || last.hash !== hash || now - last.at >= RESEND_AFTER_MS;
+}
+function themeDetectPlugin(config) {
+  const storageKey = `${STORAGE_PREFIX}${config.apiKey.slice(-16) || "default"}`;
+  let observer = null;
+  let timer = null;
+  let destroyed = false;
+  let runs = 0;
+  const run = async () => {
+    if (destroyed || runs >= MAX_RUNS_PER_PAGE) return;
+    const prefersDark = typeof window.matchMedia === "function" && window.matchMedia("(prefers-color-scheme: dark)").matches;
+    const guess = guessMode(document, prefersDark);
+    if (isFresh(readState(storageKey), guess, Date.now())) return;
+    runs++;
+    try {
+      const detector = await config.loadDetector();
+      if (!detector || destroyed) return;
+      const snapshot = detector.detectTheme();
+      if (!snapshot) return;
+      const hash = detector.snapshotHash(snapshot);
+      const state = readState(storageKey);
+      const now = Date.now();
+      const mark = () => {
+        const record = { hash, at: Date.now() };
+        state[snapshot.mode] = record;
+        state[guess] = state[guess] && guess !== snapshot.mode ? state[guess] : record;
+        writeState(storageKey, state);
+      };
+      if (!shouldSendSnapshot(state, snapshot.mode, hash, now)) {
+        mark();
+        return;
+      }
+      if (config.debug) console.log("[veo] theme snapshot", snapshot);
+      const res = await fetch(`${config.apiUrl}/v1/workspaces/theme-snapshot`, {
+        method: "POST",
+        headers: { "X-Api-Key": config.apiKey, "Content-Type": "application/json" },
+        body: JSON.stringify(snapshot),
+        credentials: "omit"
+      });
+      if (res.ok) mark();
+    } catch (err) {
+      if (config.debug) console.warn("[veo] theme detect failed", err);
+    }
+  };
+  const schedule = (delayMs) => {
+    if (timer) clearTimeout(timer);
+    timer = setTimeout(() => {
+      timer = null;
+      const idle = window.requestIdleCallback;
+      if (typeof idle === "function") idle(() => void run());
+      else void run();
+    }, delayMs);
+  };
+  return {
+    name: "theme-detect",
+    install() {
+      if (!hasWindow() || !hasDocument()) return;
+      if (document.readyState === "complete") schedule(SETTLE_MS);
+      else window.addEventListener("load", () => schedule(SETTLE_MS), { once: true });
+      if (typeof MutationObserver === "function") {
+        observer = new MutationObserver(() => schedule(1500));
+        observer.observe(document.documentElement, {
+          attributes: true,
+          attributeFilter: ["class", "data-theme", "data-mode"]
+        });
+      }
+    },
+    destroy() {
+      destroyed = true;
+      observer?.disconnect();
+      if (timer) clearTimeout(timer);
+    }
+  };
+}
+
 // src/core/queue.ts
 var RETRY_MAX_DELAY_MS = 3e4;
 var Queue = class {
@@ -437,26 +849,26 @@ var Session = class {
 };
 
 // src/core/storage.ts
-var STORAGE_PREFIX = "veo:";
+var STORAGE_PREFIX2 = "veo:";
 var ONE_YEAR_MS = 365 * 24 * 60 * 60 * 1e3;
 var LocalStorageAdapter = class {
   get(key) {
-    return localStorage.getItem(STORAGE_PREFIX + key);
+    return localStorage.getItem(STORAGE_PREFIX2 + key);
   }
   set(key, value) {
     try {
-      localStorage.setItem(STORAGE_PREFIX + key, value);
+      localStorage.setItem(STORAGE_PREFIX2 + key, value);
     } catch {
     }
   }
   remove(key) {
-    localStorage.removeItem(STORAGE_PREFIX + key);
+    localStorage.removeItem(STORAGE_PREFIX2 + key);
   }
   clear() {
     const toRemove = [];
     for (let i = 0; i < localStorage.length; i++) {
       const key = localStorage.key(i);
-      if (key?.startsWith(STORAGE_PREFIX)) toRemove.push(key);
+      if (key?.startsWith(STORAGE_PREFIX2)) toRemove.push(key);
     }
     for (const key of toRemove) localStorage.removeItem(key);
   }
@@ -467,7 +879,7 @@ function readCookies() {
 }
 var CookieAdapter = class {
   get(key) {
-    const name = `${STORAGE_PREFIX}${key}=`;
+    const name = `${STORAGE_PREFIX2}${key}=`;
     for (const cookie of readCookies()) {
       if (cookie.startsWith(name)) {
         return decodeURIComponent(cookie.slice(name.length));
@@ -478,19 +890,19 @@ var CookieAdapter = class {
   set(key, value, options) {
     const maxAgeSec = Math.floor((options?.ttlMs ?? ONE_YEAR_MS) / 1e3);
     const secure = typeof location !== "undefined" && location.protocol === "https:" ? "; Secure" : "";
-    document.cookie = `${STORAGE_PREFIX}${key}=${encodeURIComponent(
+    document.cookie = `${STORAGE_PREFIX2}${key}=${encodeURIComponent(
       value
     )}; Path=/; Max-Age=${maxAgeSec}; SameSite=Lax${secure}`;
   }
   remove(key) {
-    document.cookie = `${STORAGE_PREFIX}${key}=; Path=/; Max-Age=0; SameSite=Lax`;
+    document.cookie = `${STORAGE_PREFIX2}${key}=; Path=/; Max-Age=0; SameSite=Lax`;
   }
   clear() {
     for (const cookie of readCookies()) {
       const eq = cookie.indexOf("=");
       const name = eq === -1 ? cookie : cookie.slice(0, eq);
-      if (name.startsWith(STORAGE_PREFIX)) {
-        this.remove(name.slice(STORAGE_PREFIX.length));
+      if (name.startsWith(STORAGE_PREFIX2)) {
+        this.remove(name.slice(STORAGE_PREFIX2.length));
       }
     }
   }
@@ -779,13 +1191,23 @@ var Client = class {
 };
 
 // src/core/setup.ts
-function setupClient(config, onGuides, loadBuilder) {
+function setupClient(config, onGuides, loadBuilder, loadThemeDetector) {
   const client = new Client(config);
   client.use(spaRouterPlugin());
   if (config.autocapture !== false) {
     const autocaptureConfig = typeof config.autocapture === "object" ? config.autocapture : {};
     client.use(autocapturePlugin(autocaptureConfig));
   }
+  if (config.detectTheme !== false && loadThemeDetector && !isBuilderMode()) {
+    client.use(
+      themeDetectPlugin({
+        apiUrl: resolveApiUrl(config),
+        apiKey: config.apiKey,
+        loadDetector: loadThemeDetector,
+        ...config.debug !== void 0 ? { debug: config.debug } : {}
+      })
+    );
+  }
   onGuides(client);
   if (typeof window !== "undefined") {
     const stub = window.veo;
@@ -844,7 +1266,10 @@ 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-BKPMANUB.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')
   );
 }