veo-sdk 0.2.1 → 0.3.0

package/dist/{chunk-BBAA5BRS.mjs → chunk-CI7NWEH2.mjs}

@@ -1,3 +1,4 @@
+import { BUILDER_TOKEN_PARAM, BUILDER_ORIGIN_PARAM } from './chunk-JIU5JLI3.mjs';
 import { computePosition, offset, flip, shift, arrow } from '@floating-ui/dom';
 
 // src/utils/safe-env.ts
@@ -22,6 +23,66 @@ function hasNavigatorSendBeacon() {
   return typeof navigator !== "undefined" && typeof navigator.sendBeacon === "function";
 }
 
+// src/core/builder-token.ts
+var TOKEN_KEY = "veo:builder_token";
+var ORIGIN_KEY = "veo:builder_origin";
+function session() {
+  try {
+    return window.sessionStorage;
+  } catch {
+    return null;
+  }
+}
+function urlParams() {
+  try {
+    return new URLSearchParams(window.location.search);
+  } catch {
+    return null;
+  }
+}
+function resolveBuilderToken() {
+  if (!hasWindow()) return null;
+  const params = urlParams();
+  const fromUrl = params?.get(BUILDER_TOKEN_PARAM);
+  if (fromUrl) {
+    const store = session();
+    try {
+      store?.setItem(TOKEN_KEY, fromUrl);
+      const origin = params?.get(BUILDER_ORIGIN_PARAM);
+      if (origin) store?.setItem(ORIGIN_KEY, origin);
+    } catch {
+    }
+    return fromUrl;
+  }
+  try {
+    return session()?.getItem(TOKEN_KEY) ?? null;
+  } catch {
+    return null;
+  }
+}
+function resolveBuilderOrigin() {
+  if (!hasWindow()) return null;
+  const fromUrl = urlParams()?.get(BUILDER_ORIGIN_PARAM);
+  if (fromUrl) return fromUrl;
+  try {
+    return session()?.getItem(ORIGIN_KEY) ?? null;
+  } catch {
+    return null;
+  }
+}
+function isBuilderMode() {
+  return resolveBuilderToken() !== null;
+}
+function clearBuilderToken() {
+  if (!hasWindow()) return;
+  try {
+    const store = session();
+    store?.removeItem(TOKEN_KEY);
+    store?.removeItem(ORIGIN_KEY);
+  } catch {
+  }
+}
+
 // src/plugins/guides/constants.ts
 var GUIDE_Z_INDEX = 2147483640;
 var DEFAULT_ANCHOR_WAIT_MS = 5e3;
@@ -994,8 +1055,8 @@ function buildScale(wrapper, doc, min, max, btnClass, symbol) {
     btn.addEventListener("click", () => {
       selected = n;
       buttons.forEach((b, i) => {
-        const active2 = symbol ? i + min <= n : i + min === n;
-        b.classList.toggle("veo-scale-active", active2);
+        const active = symbol ? i + min <= n : i + min === n;
+        b.classList.toggle("veo-scale-active", active);
       });
     });
     buttons.push(btn);
@@ -1553,1043 +1614,6 @@ function safeDestroy(renderer) {
   }
 }
 
-// src/plugins/plugin.ts
-function definePlugin(plugin) {
-  return plugin;
-}
-
-// src/plugins/guides/preview-mode.ts
-var active = null;
-async function runPreviewMode(opts) {
-  if (!hasDocument()) return null;
-  active?.teardown();
-  let guide = null;
-  try {
-    const res = await fetch(`${opts.apiUrl}/v1/guides/preview-resolve`, {
-      method: "POST",
-      headers: { "Content-Type": "application/json", "X-Api-Key": opts.apiKey },
-      body: JSON.stringify({ token: opts.token })
-    });
-    if (res.ok) {
-      const data = await res.json();
-      guide = data.guide ?? null;
-    } else if (opts.debug) {
-      console.warn("[veo] preview-resolve respondi\xF3", res.status);
-    }
-  } catch (err) {
-    if (opts.debug) console.warn("[veo] preview-resolve fall\xF3:", err);
-  }
-  const submitToBackend = async (answers) => {
-    if (!guide) return false;
-    const veo = window.veo;
-    const endUserId = veo?.getEndUserId?.() ?? veo?.getAnonymousId?.() ?? null;
-    if (!endUserId) return false;
-    try {
-      const res = await fetch(`${opts.apiUrl}/v1/guides/${guide.guideId}/form-response`, {
-        method: "POST",
-        headers: { "Content-Type": "application/json", "X-Api-Key": opts.apiKey },
-        body: JSON.stringify({ endUserId, answers })
-      });
-      return res.ok;
-    } catch {
-      return false;
-    }
-  };
-  let preview = null;
-  const show = () => {
-    if (!guide) return;
-    preview?.close();
-    preview = previewGuide({
-      guideType: guide.guideType,
-      guideSteps: guide.guideSteps,
-      activationRules: guide.activationRules,
-      guideName: guide.guideName,
-      formSubmit: submitToBackend,
-      formSubmitNote: "Vista previa: guardado en TU usuario para probar el flujo."
-    });
-  };
-  const chip = mountChip({
-    label: guide ? `Vista previa: ${guide.guideName}` : "Link de preview inv\xE1lido o vencido",
-    error: !guide,
-    onReshow: guide ? show : null,
-    onClose: () => handle.teardown()
-  });
-  const handle = {
-    teardown() {
-      preview?.close();
-      preview = null;
-      chip.remove();
-      if (active === handle) active = null;
-    }
-  };
-  active = handle;
-  show();
-  return handle;
-}
-function mountChip(opts) {
-  const host = document.createElement("div");
-  host.setAttribute("data-veo-preview-chip", "");
-  const root = host.attachShadow({ mode: "open" });
-  const style = document.createElement("style");
-  style.textContent = `
-    .chip { position: fixed; bottom: 16px; right: 16px; z-index: 2147483647;
-      display: flex; align-items: center; gap: 8px; padding: 8px 12px;
-      background: #111827; color: #f9fafb; border-radius: 9999px;
-      font: 500 12px/1.2 system-ui, sans-serif; box-shadow: 0 4px 12px rgba(0,0,0,.25); }
-    .chip.error { background: #7f1d1d; }
-    .label { max-width: 240px; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
-    button { all: unset; cursor: pointer; padding: 2px 6px; border-radius: 9999px;
-      font-size: 12px; line-height: 1; }
-    button:hover { background: rgba(255,255,255,.15); }
-  `;
-  root.appendChild(style);
-  const chip = document.createElement("div");
-  chip.className = opts.error ? "chip error" : "chip";
-  const label = document.createElement("span");
-  label.className = "label";
-  label.textContent = opts.label;
-  chip.appendChild(label);
-  if (opts.onReshow) {
-    const reshow = document.createElement("button");
-    reshow.textContent = "\u21BB";
-    reshow.title = "Volver a mostrar la gu\xEDa";
-    reshow.addEventListener("click", opts.onReshow);
-    chip.appendChild(reshow);
-  }
-  const close = document.createElement("button");
-  close.textContent = "\u2715";
-  close.title = "Salir de la vista previa";
-  close.addEventListener("click", opts.onClose);
-  chip.appendChild(close);
-  root.appendChild(chip);
-  document.body.appendChild(host);
-  return { remove: () => host.remove() };
-}
-
-// src/plugins/guides/guide-frequency-cache.ts
-var STATUS_PRIORITY = {
-  shown: 1,
-  dismissed: 2,
-  completed: 2
-};
-function namespaceFromApiKey(apiKey) {
-  return apiKey.slice(-16) || "default";
-}
-var GuideFrequencyCache = class {
-  constructor(namespace) {
-    this.storageKey = `${FREQUENCY_CACHE_KEY_PREFIX}${namespace}`;
-    this.cache = this.load();
-    this.prune();
-  }
-  /**
-   * Decide si una guía debe filtrarse localmente antes de pintarla.
-   *
-   *   - `every_visit` / `always` → nunca filtra (siempre re-pinta).
-   *   - `once` → cualquier entry registrada filtra (verla ya cuenta).
-   *   - `until_dismissed` → si fue descartada O COMPLETADA (responder un
-   *     form / terminar un walkthrough es más fuerte que descartar — sin
-   *     esto, una encuesta seguiría preguntando después de respondida).
-   */
-  shouldFilter(guideId, displayFrequency) {
-    if (displayFrequency === "every_visit" || displayFrequency === "always") return false;
-    const entry = this.cache.get(guideId);
-    if (!entry) return false;
-    if (displayFrequency === "once") return true;
-    if (displayFrequency === "until_dismissed") {
-      return entry.status === "dismissed" || entry.status === "completed";
-    }
-    if (displayFrequency === "until_answered") return entry.status === "completed";
-    return false;
-  }
-  /**
-   * Registra/actualiza la entry de una guía. Nunca degrada un estado más
-   * fuerte (no convierte `dismissed` en `shown` por un re-render). Persiste
-   * cada llamada — escribir a localStorage es lo bastante barato.
-   */
-  record(guideId, status) {
-    const existing = this.cache.get(guideId);
-    if (existing && STATUS_PRIORITY[status] < STATUS_PRIORITY[existing.status]) {
-      return;
-    }
-    this.cache.set(guideId, {
-      guideId,
-      status,
-      lastInteractionAt: Date.now()
-    });
-    this.persist();
-  }
-  /** Limpia el cache (botón "reset" del demo, tests). */
-  clear() {
-    this.cache.clear();
-    this.persist();
-  }
-  /** Útil para debugging — devuelve un snapshot. */
-  snapshot() {
-    return Array.from(this.cache.values());
-  }
-  /**
-   * Limpia entries expiradas por TTL y, si aún excede el límite, descarta
-   * las más viejas hasta caber. Se ejecuta una vez en el constructor; no
-   * vale la pena correrlo a cada lectura.
-   */
-  prune() {
-    const now = Date.now();
-    let mutated = false;
-    for (const [id, entry] of this.cache) {
-      if (now - entry.lastInteractionAt > FREQUENCY_CACHE_TTL_MS) {
-        this.cache.delete(id);
-        mutated = true;
-      }
-    }
-    if (this.cache.size > FREQUENCY_CACHE_MAX_ENTRIES) {
-      const sorted = Array.from(this.cache.entries()).sort(
-        (a, b) => a[1].lastInteractionAt - b[1].lastInteractionAt
-      );
-      const excess = this.cache.size - FREQUENCY_CACHE_MAX_ENTRIES;
-      for (let i = 0; i < excess; i++) {
-        const tuple = sorted[i];
-        if (tuple) this.cache.delete(tuple[0]);
-      }
-      mutated = true;
-    }
-    if (mutated) this.persist();
-  }
-  load() {
-    if (typeof localStorage === "undefined") return /* @__PURE__ */ new Map();
-    try {
-      const raw = localStorage.getItem(this.storageKey);
-      if (!raw) return /* @__PURE__ */ new Map();
-      const parsed = JSON.parse(raw);
-      if (!Array.isArray(parsed)) return /* @__PURE__ */ new Map();
-      const entries = [];
-      for (const item of parsed) {
-        if (item && typeof item === "object" && typeof item.guideId === "string" && typeof item.lastInteractionAt === "number" && ["shown", "dismissed", "completed"].includes(item.status)) {
-          const e = item;
-          entries.push([e.guideId, e]);
-        }
-      }
-      return new Map(entries);
-    } catch {
-      return /* @__PURE__ */ new Map();
-    }
-  }
-  persist() {
-    if (typeof localStorage === "undefined") return;
-    try {
-      const serialized = JSON.stringify(Array.from(this.cache.values()));
-      localStorage.setItem(this.storageKey, serialized);
-    } catch {
-    }
-  }
-};
-
-// src/plugins/guides/guide-resolver-client.ts
-var GuideResolverClient = class {
-  constructor(apiUrl, apiKey, debug = false) {
-    this.apiUrl = apiUrl;
-    this.apiKey = apiKey;
-    this.debug = debug;
-  }
-  async resolve(endUserId, pageUrl) {
-    const params = new URLSearchParams({ endUserId, pageUrl });
-    let response;
-    try {
-      response = await fetch(`${this.apiUrl}/v1/guides/resolve?${params.toString()}`, {
-        method: "GET",
-        headers: { "X-Api-Key": this.apiKey },
-        credentials: "omit"
-      });
-    } catch (err) {
-      if (this.debug) console.error("[veo] guides resolve fetch failed:", err);
-      return [];
-    }
-    if (!response.ok) {
-      if (this.debug) console.warn("[veo] guides resolve HTTP", response.status);
-      return [];
-    }
-    try {
-      const data = await response.json();
-      return Array.isArray(data.guides) ? data.guides : [];
-    } catch (err) {
-      if (this.debug) console.error("[veo] guides resolve parse failed:", err);
-      return [];
-    }
-  }
-  /**
-   * Trae una guía específica por ID, sin pasar por la lógica de
-   * activación. La usa el controller para resumir un walkthrough entre
-   * páginas: el `resolve` no devuelve la guía si la URL actual no
-   * matchea, pero el walkthrough activo debe poder consultarla igual.
-   *
-   * El endpoint backend (`GET /v1/guides/:guideId`) devuelve `GuideResponse`,
-   * un superset de `ResolvedGuide` con campos de audit. Acá descartamos los
-   * extra y nos quedamos con el shape que el resto del SDK ya consume.
-   *
-   * Devuelve `null` en cualquier error (404, red, parse) — el caller debe
-   * tratarlo como "guía ya no existe" y cancelar el walkthrough limpiamente.
-   */
-  async fetchById(guideId) {
-    let response;
-    try {
-      response = await fetch(`${this.apiUrl}/v1/guides/${encodeURIComponent(guideId)}`, {
-        method: "GET",
-        headers: { "X-Api-Key": this.apiKey },
-        credentials: "omit"
-      });
-    } catch (err) {
-      if (this.debug) console.error("[veo] guides fetchById network failed:", err);
-      return null;
-    }
-    if (!response.ok) {
-      if (this.debug) console.warn("[veo] guides fetchById HTTP", response.status);
-      return null;
-    }
-    try {
-      const data = await response.json();
-      if (typeof data.guideId !== "string" || typeof data.guideName !== "string" || typeof data.guideType !== "string" || !Array.isArray(data.guideSteps) || !data.activationRules || typeof data.displayFrequency !== "string" || typeof data.displayPriority !== "number") {
-        if (this.debug) console.warn("[veo] guides fetchById: unexpected shape");
-        return null;
-      }
-      return {
-        guideId: data.guideId,
-        guideName: data.guideName,
-        guideType: data.guideType,
-        guideSteps: data.guideSteps,
-        activationRules: data.activationRules,
-        displayFrequency: data.displayFrequency,
-        displayPriority: data.displayPriority
-      };
-    } catch (err) {
-      if (this.debug) console.error("[veo] guides fetchById parse failed:", err);
-      return null;
-    }
-  }
-};
-
-// src/plugins/guides/guide-tracker-client.ts
-function toWire(payload) {
-  const wire = {
-    endUserId: payload.endUserId,
-    interactionType: payload.action
-  };
-  if (payload.sessionId) wire.sessionId = payload.sessionId;
-  if (typeof payload.stepIndex === "number") wire.stepPosition = payload.stepIndex;
-  if (payload.pageUrl) wire.pageUrl = payload.pageUrl;
-  if (payload.pagePath) wire.pagePath = payload.pagePath;
-  return wire;
-}
-var GuideTrackerClient = class {
-  constructor(apiUrl, apiKey) {
-    this.apiUrl = apiUrl;
-    this.apiKey = apiKey;
-  }
-  async send(request) {
-    const url = this.buildUrl(request.guideId);
-    const response = await fetch(url, {
-      method: "POST",
-      headers: {
-        "X-Api-Key": this.apiKey,
-        "Content-Type": "application/json"
-      },
-      body: JSON.stringify(toWire(request.payload)),
-      credentials: "omit"
-    });
-    if (!response.ok) {
-      throw new Error(`guide interaction send failed: HTTP ${response.status}`);
-    }
-  }
-  /**
-   * Envío "fire-and-forget" en pagehide. Devuelve `false` si el navegador
-   * no acepta el beacon (cola llena, no soportado) — en ese caso la queue
-   * sabrá que perdió el envío.
-   */
-  sendBeacon(request) {
-    if (typeof navigator === "undefined" || typeof navigator.sendBeacon !== "function") {
-      return false;
-    }
-    const url = `${this.buildUrl(request.guideId)}?key=${encodeURIComponent(this.apiKey)}`;
-    const blob = new Blob([JSON.stringify(toWire(request.payload))], {
-      type: "application/json"
-    });
-    try {
-      return navigator.sendBeacon(url, blob);
-    } catch {
-      return false;
-    }
-  }
-  buildUrl(guideId) {
-    return `${this.apiUrl}/v1/guides/${encodeURIComponent(guideId)}/interactions`;
-  }
-};
-
-// src/plugins/guides/guide-tracker-queue.ts
-var GuideTrackerQueue = class {
-  constructor(config) {
-    this.config = config;
-    this.buffer = [];
-    this.timer = null;
-    this.flushing = false;
-    this.unloadCleanup = null;
-    this.startTimer();
-    this.installUnloadHandler();
-  }
-  /** Tamaño actual del buffer (útil para debug/stats en el demo). */
-  get size() {
-    return this.buffer.length;
-  }
-  /**
-   * Encola una interaction. Si el buffer alcanza `batchSize`, dispara
-   * `flush()` inmediato.
-   */
-  enqueue(request) {
-    this.buffer.push({
-      guideId: request.guideId,
-      payload: request.payload,
-      attempts: 0,
-      enqueuedAt: Date.now()
-    });
-    if (this.buffer.length >= this.config.batchSize) {
-      void this.flush();
-    }
-  }
-  /**
-   * Envía todo el buffer en paralelo. Items que fallan vuelven al buffer
-   * si todavía tienen reintentos disponibles. Idempotente con respecto a
-   * flushes concurrentes (el segundo es un no-op).
-   */
-  async flush() {
-    if (this.flushing || this.buffer.length === 0) return;
-    this.flushing = true;
-    const batch = this.buffer.splice(0, this.buffer.length);
-    const results = await Promise.allSettled(
-      batch.map(
-        (item) => this.config.client.send({ guideId: item.guideId, payload: item.payload })
-      )
-    );
-    for (let i = 0; i < results.length; i++) {
-      const result = results[i];
-      const item = batch[i];
-      if (!result || !item) continue;
-      if (result.status === "fulfilled") continue;
-      item.attempts += 1;
-      if (item.attempts < this.config.maxRetries) {
-        this.buffer.push(item);
-      } else {
-        this.safeOnError(result.reason, item);
-      }
-    }
-    this.flushing = false;
-  }
-  /**
-   * Drena el buffer vía `sendBeacon`. Síncrono, sin retry. Para pagehide.
-   */
-  flushBeacon() {
-    if (this.buffer.length === 0) return;
-    const batch = this.buffer.splice(0, this.buffer.length);
-    for (const item of batch) {
-      this.config.client.sendBeacon({ guideId: item.guideId, payload: item.payload });
-    }
-  }
-  destroy() {
-    if (this.timer) clearInterval(this.timer);
-    this.timer = null;
-    this.unloadCleanup?.();
-    this.unloadCleanup = null;
-  }
-  startTimer() {
-    if (typeof window === "undefined") return;
-    this.timer = setInterval(() => {
-      void this.flush();
-    }, this.config.flushIntervalMs);
-  }
-  installUnloadHandler() {
-    if (typeof window === "undefined") return;
-    const onPagehide = () => this.flushBeacon();
-    const onVisibility = () => {
-      if (document.visibilityState === "hidden") this.flushBeacon();
-    };
-    window.addEventListener("pagehide", onPagehide);
-    window.addEventListener("visibilitychange", onVisibility);
-    this.unloadCleanup = () => {
-      window.removeEventListener("pagehide", onPagehide);
-      window.removeEventListener("visibilitychange", onVisibility);
-    };
-  }
-  safeOnError(reason, item) {
-    if (!this.config.onError) return;
-    const error = reason instanceof Error ? reason : new Error(String(reason));
-    try {
-      this.config.onError(error, item);
-    } catch {
-    }
-  }
-};
-
-// src/plugins/guides/walkthrough-state.ts
-var WalkthroughStateManager = class {
-  constructor(namespace) {
-    this.state = null;
-    this.storageKey = `${WALKTHROUGH_STATE_KEY_PREFIX}${namespace}`;
-    this.state = this.load();
-    if (this.state && this.isAbandoned(this.state)) {
-      this.clear();
-    }
-  }
-  /**
-   * Estado del walkthrough activo. Devuelve `null` si no hay ninguno o si
-   * el último progreso fue hace más del timeout (en ese caso también
-   * limpia el storage como side-effect).
-   */
-  current() {
-    if (!this.state) return null;
-    if (this.isAbandoned(this.state)) {
-      this.clear();
-      return null;
-    }
-    return this.state;
-  }
-  /** Atajo legible para el controller. */
-  hasActive() {
-    return this.current() !== null;
-  }
-  /**
-   * Inicia un nuevo walkthrough en step 0. Sobreescribe cualquier estado
-   * previo — los callers (controller) son responsables de verificar
-   * `hasActive()` antes si necesitan exclusividad.
-   */
-  start(guideId, totalSteps) {
-    const now = Date.now();
-    this.state = {
-      guideId,
-      totalSteps,
-      currentStepIndex: 0,
-      startedAt: now,
-      lastProgressAt: now
-    };
-    this.persist();
-    return this.state;
-  }
-  /**
-   * Avanza al siguiente step. Si el step resultante excede `totalSteps`,
-   * devuelve `null` y NO toca el estado — el controller debe interpretar
-   * eso como "ya estamos en el último, no hay próximo" y disparar
-   * `complete` vía el handler del botón "Finalizar".
-   */
-  advance() {
-    if (!this.state) return null;
-    const next = this.state.currentStepIndex + 1;
-    if (next >= this.state.totalSteps) return null;
-    this.state = {
-      ...this.state,
-      currentStepIndex: next,
-      lastProgressAt: Date.now()
-    };
-    this.persist();
-    return this.state;
-  }
-  /**
-   * Retrocede al step anterior. En step 0 no hace nada y devuelve el
-   * estado tal cual (el botón "Atrás" no debería estar visible en el
-   * primer step, pero por defensa el manager también lo guard-ea).
-   */
-  back() {
-    if (!this.state) return null;
-    if (this.state.currentStepIndex === 0) return this.state;
-    this.state = {
-      ...this.state,
-      currentStepIndex: this.state.currentStepIndex - 1,
-      lastProgressAt: Date.now()
-    };
-    this.persist();
-    return this.state;
-  }
-  /** Limpia el estado activo (skip, complete, abandono, guía borrada). */
-  clear() {
-    this.state = null;
-    if (typeof localStorage === "undefined") return;
-    try {
-      localStorage.removeItem(this.storageKey);
-    } catch {
-    }
-  }
-  isAbandoned(state) {
-    return Date.now() - state.lastProgressAt > WALKTHROUGH_ABANDONMENT_TIMEOUT_MS;
-  }
-  load() {
-    if (typeof localStorage === "undefined") return null;
-    try {
-      const raw = localStorage.getItem(this.storageKey);
-      if (!raw) return null;
-      const parsed = JSON.parse(raw);
-      if (!parsed || typeof parsed !== "object") return null;
-      const candidate = parsed;
-      if (typeof candidate.guideId !== "string" || typeof candidate.totalSteps !== "number" || typeof candidate.currentStepIndex !== "number" || typeof candidate.startedAt !== "number" || typeof candidate.lastProgressAt !== "number") {
-        return null;
-      }
-      return candidate;
-    } catch {
-      return null;
-    }
-  }
-  persist() {
-    if (typeof localStorage === "undefined" || !this.state) return;
-    try {
-      localStorage.setItem(this.storageKey, JSON.stringify(this.state));
-    } catch {
-    }
-  }
-};
-
-// src/plugins/guides/guides-controller.ts
-var STATUS_BY_ACTION = {
-  shown: "shown",
-  dismissed: "dismissed",
-  cta_clicked: null,
-  step_advanced: null,
-  step_back: null,
-  completed: "completed"
-};
-var GuidesController = class {
-  constructor(client, config) {
-    this.client = client;
-    this.activeRenderers = /* @__PURE__ */ new Set();
-    /**
-     * Guías single-step actualmente en pantalla, por `guideId`. Evita repintar/
-     * duplicar la misma guía en cada pageview de una SPA (p.ej. una guía inline
-     * anclada a un elemento persistente). Se libera al cerrarse la guía.
-     */
-    this.activeByGuideId = /* @__PURE__ */ new Map();
-    this.dispatched = /* @__PURE__ */ new Set();
-    this.activeWalkthroughRenderer = null;
-    this.activeWalkthroughGuide = null;
-    this.debug = config.debug === true;
-    this.apiUrl = config.apiUrl;
-    this.apiKey = config.apiKey;
-    this.resolver = config.resolver ?? new GuideResolverClient(config.apiUrl, config.apiKey, this.debug);
-    if (config.trackerQueue) {
-      this.trackerQueue = config.trackerQueue;
-    } else {
-      const httpClient = new GuideTrackerClient(config.apiUrl, config.apiKey);
-      this.trackerQueue = new GuideTrackerQueue({
-        client: httpClient,
-        flushIntervalMs: DEFAULT_TRACKER_FLUSH_INTERVAL_MS,
-        batchSize: DEFAULT_TRACKER_BATCH_SIZE,
-        maxRetries: DEFAULT_TRACKER_MAX_RETRIES,
-        onError: (err, item) => {
-          if (this.debug) {
-            console.warn(
-              `[veo] dropped guide interaction after retries: guideId=${item.guideId} action=${item.payload.action}`,
-              err
-            );
-          }
-        }
-      });
-    }
-    const namespace = namespaceFromApiKey(config.apiKey);
-    this.frequencyCache = config.frequencyCache ?? new GuideFrequencyCache(namespace);
-    this.walkthroughState = config.walkthroughState ?? new WalkthroughStateManager(namespace);
-  }
-  /** Cuántas interactions hay pendientes de envío. Útil para debug en demo. */
-  get pendingInteractions() {
-    return this.trackerQueue.size;
-  }
-  /** Limpia el cache local (botón "reset" del demo, tests). */
-  clearFrequencyCache() {
-    this.frequencyCache.clear();
-  }
-  /** Limpia el walkthrough activo (debug del demo). */
-  clearWalkthroughState() {
-    this.tearDownWalkthrough();
-  }
-  /** Punto de entrada principal. Llamado en cada pageview/identify. */
-  async checkGuides(pageUrl, sessionId) {
-    const endUserId = this.client.getEndUserId();
-    if (!endUserId) {
-      if (this.debug) console.log("[veo] guides: skipped, no endUserId yet");
-      return;
-    }
-    if (await this.tryResumeWalkthrough(endUserId, sessionId, pageUrl)) {
-      return;
-    }
-    let guides;
-    try {
-      guides = await this.resolver.resolve(endUserId, pageUrl);
-    } catch (err) {
-      if (this.debug) console.error("[veo] guides resolver threw:", err);
-      return;
-    }
-    if (this.debug) console.log(`[veo] guides: ${guides.length} eligible at ${pageUrl}`);
-    for (const guide of guides) {
-      if (this.frequencyCache.shouldFilter(guide.guideId, guide.displayFrequency)) {
-        if (this.debug) console.log(`[veo] guides: filtered locally guideId=${guide.guideId}`);
-        continue;
-      }
-      if (this.activeByGuideId.has(guide.guideId)) {
-        if (this.debug) console.log(`[veo] guides: already shown guideId=${guide.guideId}`);
-        continue;
-      }
-      if (guide.guideType === "walkthrough" && guide.guideSteps.length > 1) {
-        if (this.walkthroughState.hasActive()) {
-          if (this.debug)
-            console.log(`[veo] guides: walkthrough ${guide.guideId} skipped (another active)`);
-          continue;
-        }
-        await this.startWalkthrough(guide, endUserId, sessionId, pageUrl);
-        continue;
-      }
-      this.runSingleStepRender(guide, sessionId, pageUrl);
-    }
-  }
-  /** Cierra todas las guías activas, limpia cache de dispatch y para timers. */
-  destroy() {
-    for (const renderer of this.activeRenderers) {
-      try {
-        renderer.destroy();
-      } catch (err) {
-        if (this.debug) console.error("[veo] renderer destroy failed:", err);
-      }
-    }
-    this.activeRenderers.clear();
-    this.activeByGuideId.clear();
-    if (this.activeWalkthroughRenderer) {
-      try {
-        this.activeWalkthroughRenderer.destroy();
-      } catch {
-      }
-      this.activeWalkthroughRenderer = null;
-      this.activeWalkthroughGuide = null;
-    }
-    this.dispatched.clear();
-    this.trackerQueue.destroy();
-  }
-  runSingleStepRender(guide, sessionId, pageUrl) {
-    const renderer = this.createSingleStepRenderer(guide.guideType);
-    if (!renderer) return;
-    this.activeByGuideId.set(guide.guideId, renderer);
-    const delayMs = guide.activationRules.delayMs ?? 0;
-    window.setTimeout(
-      () => this.mountSingleStepRenderer(guide, renderer, sessionId, pageUrl),
-      delayMs
-    );
-  }
-  mountSingleStepRenderer(guide, renderer, sessionId, pageUrl) {
-    this.activeRenderers.add(renderer);
-    this.activeByGuideId.set(guide.guideId, renderer);
-    const onClose = () => {
-      renderer.destroy();
-      this.activeRenderers.delete(renderer);
-      if (this.activeByGuideId.get(guide.guideId) === renderer) {
-        this.activeByGuideId.delete(guide.guideId);
-      }
-    };
-    const onInteraction = (event) => {
-      this.handleInteraction(guide, sessionId, pageUrl, event);
-    };
-    const onTrack = (eventName, properties) => {
-      this.client.track(eventName, properties);
-    };
-    const onFormSubmit = (answers) => this.submitFormResponse(guide.guideId, answers);
-    try {
-      void renderer.render({ guide, onInteraction, onClose, onTrack, onFormSubmit });
-    } catch (err) {
-      if (this.debug) console.error("[veo] renderer.render threw:", err);
-      this.activeRenderers.delete(renderer);
-      if (this.activeByGuideId.get(guide.guideId) === renderer) {
-        this.activeByGuideId.delete(guide.guideId);
-      }
-    }
-  }
-  /**
-   * Si hay un walkthrough persistido, intenta pintar el step actual en
-   * la página actual. Retorna `true` si lo intentó (sea éxito o cancel),
-   * `false` si no había walkthrough activo.
-   *
-   * Cancela limpiamente (sin enviar `dismissed` falso) cuando:
-   *   - La guía fue eliminada en el backend (404 → `fetchById` devuelve null).
-   *   - La guía cambió de tipo y ya no es walkthrough.
-   *   - El selector del step actual no aparece dentro del timeout.
-   */
-  async tryResumeWalkthrough(endUserId, sessionId, pageUrl) {
-    const state = this.walkthroughState.current();
-    if (!state) return false;
-    const guide = await this.resolver.fetchById(state.guideId);
-    if (!guide || guide.guideType !== "walkthrough") {
-      if (this.debug)
-        console.log(`[veo] guides: walkthrough ${state.guideId} no longer available, cleaning up`);
-      this.tearDownWalkthrough();
-      return true;
-    }
-    const stepIndex = Math.min(state.currentStepIndex, guide.guideSteps.length - 1);
-    await this.renderWalkthroughStep(guide, stepIndex, endUserId, sessionId, pageUrl);
-    return true;
-  }
-  async startWalkthrough(guide, endUserId, sessionId, pageUrl) {
-    this.walkthroughState.start(guide.guideId, guide.guideSteps.length);
-    const rendered = await this.renderWalkthroughStep(guide, 0, endUserId, sessionId, pageUrl);
-    if (!rendered) return;
-    this.enqueueInteractionOnce(guide.guideId, endUserId, sessionId, pageUrl, "shown", 0);
-    this.frequencyCache.record(guide.guideId, "shown");
-  }
-  /**
-   * Pinta el step indicado. Reusa la guía (no fetcha): el caller debe
-   * traerla. Retorna `true` si el render fue exitoso. En caso contrario
-   * ya disparó el teardown — el caller no debe seguir reportando.
-   */
-  async renderWalkthroughStep(guide, stepIndex, endUserId, sessionId, pageUrl) {
-    if (this.activeWalkthroughRenderer) {
-      this.activeWalkthroughRenderer.destroy();
-      this.activeWalkthroughRenderer = null;
-    }
-    const renderer = new WalkthroughRenderer();
-    this.activeWalkthroughGuide = guide;
-    const callbacks = {
-      onNext: () => this.handleWalkthroughNext(endUserId, sessionId, pageUrl),
-      onBack: () => this.handleWalkthroughBack(endUserId, sessionId, pageUrl),
-      onSkip: () => this.handleWalkthroughSkip(endUserId, sessionId, pageUrl),
-      onComplete: () => this.handleWalkthroughComplete(endUserId, sessionId, pageUrl)
-    };
-    let success = false;
-    try {
-      success = await renderer.render({ guide, currentStepIndex: stepIndex, callbacks });
-    } catch (err) {
-      if (this.debug) console.error("[veo] walkthrough renderer threw:", err);
-    }
-    if (!success) {
-      if (this.debug)
-        console.warn(
-          `[veo] walkthrough ${guide.guideId} step ${stepIndex} could not render, cancelling`
-        );
-      this.tearDownWalkthrough();
-      return false;
-    }
-    this.activeWalkthroughRenderer = renderer;
-    return true;
-  }
-  handleWalkthroughNext(endUserId, sessionId, pageUrl) {
-    const guide = this.activeWalkthroughGuide;
-    if (!guide) return;
-    const newState = this.walkthroughState.advance();
-    if (!newState) {
-      this.handleWalkthroughComplete(endUserId, sessionId, pageUrl);
-      return;
-    }
-    this.enqueueInteraction(
-      guide.guideId,
-      endUserId,
-      sessionId,
-      pageUrl,
-      "step_advanced",
-      newState.currentStepIndex
-    );
-    void this.renderWalkthroughStep(
-      guide,
-      newState.currentStepIndex,
-      endUserId,
-      sessionId,
-      pageUrl
-    );
-  }
-  handleWalkthroughBack(endUserId, sessionId, pageUrl) {
-    const guide = this.activeWalkthroughGuide;
-    if (!guide) return;
-    const state = this.walkthroughState.current();
-    if (!state || state.currentStepIndex === 0) return;
-    const newState = this.walkthroughState.back();
-    if (!newState) return;
-    this.enqueueInteraction(
-      guide.guideId,
-      endUserId,
-      sessionId,
-      pageUrl,
-      "step_back",
-      newState.currentStepIndex
-    );
-    void this.renderWalkthroughStep(
-      guide,
-      newState.currentStepIndex,
-      endUserId,
-      sessionId,
-      pageUrl
-    );
-  }
-  handleWalkthroughSkip(endUserId, sessionId, pageUrl) {
-    const guide = this.activeWalkthroughGuide;
-    const state = this.walkthroughState.current();
-    if (!guide || !state) return;
-    this.enqueueInteraction(
-      guide.guideId,
-      endUserId,
-      sessionId,
-      pageUrl,
-      "dismissed",
-      state.currentStepIndex
-    );
-    this.frequencyCache.record(guide.guideId, "dismissed");
-    this.tearDownWalkthrough();
-  }
-  handleWalkthroughComplete(endUserId, sessionId, pageUrl) {
-    const guide = this.activeWalkthroughGuide;
-    const state = this.walkthroughState.current();
-    if (!guide || !state) return;
-    this.enqueueInteraction(
-      guide.guideId,
-      endUserId,
-      sessionId,
-      pageUrl,
-      "completed",
-      state.currentStepIndex
-    );
-    this.frequencyCache.record(guide.guideId, "completed");
-    this.tearDownWalkthrough();
-  }
-  tearDownWalkthrough() {
-    if (this.activeWalkthroughRenderer) {
-      try {
-        this.activeWalkthroughRenderer.destroy();
-      } catch {
-      }
-    }
-    this.activeWalkthroughRenderer = null;
-    this.activeWalkthroughGuide = null;
-    this.walkthroughState.clear();
-  }
-  /**
-   * Tras cada interaction single-step:
-   *   1. dedupe (no enviar 2× la misma `(guideId, action)` por sesión)
-   *   2. actualizar el cache local si corresponde
-   *   3. encolar el POST
-   *
-   * El endUserId se lee del client EN ESTE MOMENTO (no en el render),
-   * por si el usuario se identificó después de que la guía apareció.
-   */
-  handleInteraction(guide, sessionId, pageUrl, event) {
-    const dedupKey = `${guide.guideId}:${event.action}`;
-    if (this.dispatched.has(dedupKey)) {
-      if (this.debug) console.log(`[veo] guides: dedup hit ${dedupKey}`);
-      return;
-    }
-    this.dispatched.add(dedupKey);
-    const cacheStatus = STATUS_BY_ACTION[event.action];
-    if (cacheStatus) this.frequencyCache.record(guide.guideId, cacheStatus);
-    const endUserId = this.client.getEndUserId();
-    if (!endUserId) {
-      if (this.debug)
-        console.warn("[veo] guides: interaction without endUserId \u2014 skipping enqueue");
-      return;
-    }
-    this.trackerQueue.enqueue({
-      guideId: guide.guideId,
-      payload: {
-        endUserId,
-        sessionId,
-        action: event.action,
-        stepIndex: event.stepIndex,
-        pageUrl,
-        pagePath: extractPath(pageUrl)
-      }
-    });
-  }
-  /**
-   * Encola una interacción de walkthrough SIN pasar por el dedup set.
-   * Acciones como `step_advanced` se repiten naturalmente (cada next es
-   * una navegación distinta) y deduplicarlas perdería datos.
-   */
-  enqueueInteraction(guideId, endUserId, sessionId, pageUrl, action, stepIndex) {
-    this.trackerQueue.enqueue({
-      guideId,
-      payload: {
-        endUserId,
-        sessionId,
-        action,
-        stepIndex,
-        pageUrl,
-        pagePath: extractPath(pageUrl)
-      }
-    });
-  }
-  /**
-   * Encola con dedup por sesión del SDK. Para `shown` del primer step:
-   * no queremos re-emitirlo si el usuario navega entre dos páginas que
-   * matchean el mismo step.
-   */
-  enqueueInteractionOnce(guideId, endUserId, sessionId, pageUrl, action, stepIndex) {
-    const dedupKey = `${guideId}:${action}:${stepIndex}`;
-    if (this.dispatched.has(dedupKey)) return;
-    this.dispatched.add(dedupKey);
-    this.enqueueInteraction(guideId, endUserId, sessionId, pageUrl, action, stepIndex);
-  }
-  createSingleStepRenderer(type) {
-    switch (type) {
-      case "modal":
-        return new ModalRenderer();
-      case "banner":
-        return new BannerRenderer();
-      case "tooltip":
-        return new TooltipRenderer();
-      case "custom":
-        return new CustomRenderer();
-      case "inline":
-        return new InlineRenderer();
-      case "inline-custom":
-        return new InlineCustomRenderer();
-      case "form":
-        return new FormRenderer();
-      case "inline-form":
-        return new InlineFormRenderer();
-      case "walkthrough":
-        return null;
-    }
-  }
-  /**
-   * Envía las respuestas de una guía `form` al backend, que las mergea como
-   * propiedades del usuario. Usa el endUserId actual (o el anónimo si aún no
-   * hubo identify — el backend pre-crea la fila igual que identify).
-   */
-  async submitFormResponse(guideId, answers) {
-    const endUserId = this.client.getEndUserId() ?? this.client.getAnonymousId();
-    try {
-      const res = await fetch(`${this.apiUrl}/v1/guides/${guideId}/form-response`, {
-        method: "POST",
-        headers: { "Content-Type": "application/json", "X-Api-Key": this.apiKey },
-        body: JSON.stringify({ endUserId, answers })
-      });
-      if (!res.ok && this.debug) {
-        console.warn("[veo] form-response respondi\xF3", res.status);
-      }
-      return res.ok;
-    } catch (err) {
-      if (this.debug) console.warn("[veo] form-response fall\xF3:", err);
-      return false;
-    }
-  }
-};
-function extractPath(url) {
-  try {
-    return new URL(url).pathname;
-  } catch {
-    return "/";
-  }
-}
-
-// src/plugins/guides/index.ts
-function guidesPlugin(config) {
-  return definePlugin({
-    name: "guides",
-    install(client) {
-      if (!hasWindow()) return;
-      const controller = new GuidesController(client, config);
-      window.__veoGuides = { controller };
-      client.on("identify", ({ sessionId }) => {
-        void controller.checkGuides(window.location.href, sessionId);
-      });
-      client.on("pageview", ({ url, sessionId }) => {
-        void controller.checkGuides(url, sessionId);
-      });
-      void controller.checkGuides(window.location.href, client.getSessionId());
-    }
-  });
-}
-
 // src/plugins/autocapture/constants.ts
 var DEFAULT_AUTOCAPTURE_CONFIG = {
   enabled: true,
@@ -2723,6 +1747,6 @@ function buildSelectorPath(element, maxAncestors = 5) {
   return parts.join(" > ");
 }
 
-export { ALWAYS_BLOCK_SELECTORS, DEFAULT_AUTOCAPTURE_CONFIG, MAX_ANCESTORS, PRIORITY_ATTRIBUTES, SENSITIVE_ATTRIBUTES, buildSelectorPath, closeGuidePreview, definePlugin, filterHumanClasses, guidesPlugin, hasDocument, hasLocalStorage, hasNavigatorSendBeacon, hasWindow, previewGuide, runPreviewMode, uuidv7 };
-//# sourceMappingURL=chunk-BBAA5BRS.mjs.map
-//# sourceMappingURL=chunk-BBAA5BRS.mjs.map
+export { ALWAYS_BLOCK_SELECTORS, BannerRenderer, CustomRenderer, DEFAULT_AUTOCAPTURE_CONFIG, DEFAULT_TRACKER_BATCH_SIZE, DEFAULT_TRACKER_FLUSH_INTERVAL_MS, DEFAULT_TRACKER_MAX_RETRIES, FREQUENCY_CACHE_KEY_PREFIX, FREQUENCY_CACHE_MAX_ENTRIES, FREQUENCY_CACHE_TTL_MS, FormRenderer, InlineCustomRenderer, InlineFormRenderer, InlineRenderer, MAX_ANCESTORS, ModalRenderer, PRIORITY_ATTRIBUTES, SENSITIVE_ATTRIBUTES, TooltipRenderer, WALKTHROUGH_ABANDONMENT_TIMEOUT_MS, WALKTHROUGH_STATE_KEY_PREFIX, WalkthroughRenderer, buildSelectorPath, clearBuilderToken, closeGuidePreview, filterHumanClasses, hasDocument, hasLocalStorage, hasNavigatorSendBeacon, hasWindow, isBuilderMode, previewGuide, resolveBuilderOrigin, resolveBuilderToken, uuidv7 };
+//# sourceMappingURL=chunk-CI7NWEH2.mjs.map
+//# sourceMappingURL=chunk-CI7NWEH2.mjs.map