veo-sdk 0.2.1 → 0.3.0

package/dist/chunk-G5CKTGEG.mjs

@@ -0,0 +1,1042 @@
+import { hasDocument, hasWindow, previewGuide, DEFAULT_TRACKER_MAX_RETRIES, DEFAULT_TRACKER_BATCH_SIZE, DEFAULT_TRACKER_FLUSH_INTERVAL_MS, WalkthroughRenderer, InlineFormRenderer, FormRenderer, InlineCustomRenderer, InlineRenderer, CustomRenderer, TooltipRenderer, BannerRenderer, ModalRenderer, FREQUENCY_CACHE_KEY_PREFIX, FREQUENCY_CACHE_TTL_MS, FREQUENCY_CACHE_MAX_ENTRIES, WALKTHROUGH_STATE_KEY_PREFIX, WALKTHROUGH_ABANDONMENT_TIMEOUT_MS } from './chunk-CI7NWEH2.mjs';
+
+// 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());
+    }
+  });
+}
+
+export { definePlugin, guidesPlugin, runPreviewMode };
+//# sourceMappingURL=chunk-G5CKTGEG.mjs.map
+//# sourceMappingURL=chunk-G5CKTGEG.mjs.map