veo-sdk 0.1.0 → 0.2.0

package/dist/builder.cjs

@@ -0,0 +1,2072 @@
+'use strict';
+
+var dom = require('@floating-ui/dom');
+
+// src/utils/safe-env.ts
+function hasWindow() {
+  return typeof window !== "undefined";
+}
+function hasDocument() {
+  return typeof document !== "undefined";
+}
+
+// src/plugins/guides/constants.ts
+var GUIDE_Z_INDEX = 2147483640;
+var DEFAULT_ANCHOR_WAIT_MS = 5e3;
+var SAFE_URL_PROTOCOLS = ["http:", "https:"];
+var GUIDE_HOST_ATTR = "data-veo-guide";
+var WALKTHROUGH_STEP_SELECTOR_TIMEOUT_MS = 5e3;
+
+// src/plugins/guides/block-builder.ts
+function buildStepContent(step, doc, callbacks) {
+  const container = doc.createElement("div");
+  container.className = "veo-guide-content";
+  if (typeof step.imageUrl === "string" && step.imageUrl && isSafeUrl(step.imageUrl)) {
+    const img = doc.createElement("img");
+    img.className = "veo-guide-image";
+    img.src = step.imageUrl;
+    img.alt = typeof step.title === "string" ? step.title : "";
+    container.appendChild(img);
+  }
+  if (typeof step.title === "string" && step.title) {
+    const heading = doc.createElement("h2");
+    heading.className = "veo-guide-title";
+    heading.textContent = step.title;
+    container.appendChild(heading);
+  }
+  if (typeof step.content === "string" && step.content) {
+    const paragraph = doc.createElement("p");
+    paragraph.className = "veo-guide-text";
+    paragraph.textContent = step.content;
+    container.appendChild(paragraph);
+  }
+  const actions = doc.createElement("div");
+  actions.className = "veo-guide-actions";
+  if (typeof step.ctaText === "string" && step.ctaText) {
+    const cta = doc.createElement("button");
+    cta.type = "button";
+    cta.className = "veo-guide-cta";
+    cta.textContent = step.ctaText;
+    cta.addEventListener("click", () => {
+      const action = step.ctaAction ?? "dismiss";
+      const ctaUrl = readCtaUrl(step);
+      callbacks.onCtaClick(action, ctaUrl);
+    });
+    actions.appendChild(cta);
+  }
+  container.appendChild(actions);
+  const closeBtn = doc.createElement("button");
+  closeBtn.type = "button";
+  closeBtn.className = "veo-guide-close";
+  closeBtn.setAttribute("aria-label", "Cerrar");
+  closeBtn.textContent = "\xD7";
+  closeBtn.addEventListener("click", () => callbacks.onDismiss());
+  container.appendChild(closeBtn);
+  return container;
+}
+function isSafeUrl(url) {
+  if (typeof url !== "string" || url.length === 0) return false;
+  try {
+    const base = typeof window !== "undefined" ? window.location.href : "http://localhost/";
+    const parsed = new URL(url, base);
+    return SAFE_URL_PROTOCOLS.includes(parsed.protocol);
+  } catch {
+    return false;
+  }
+}
+function readCtaUrl(step) {
+  const candidate = step.style?.ctaUrl;
+  if (typeof candidate !== "string") return void 0;
+  return isSafeUrl(candidate) ? candidate : void 0;
+}
+
+// src/plugins/guides/guide-design.ts
+var DARK_THEME = {
+  "--veo-bg": "#1f2937",
+  "--veo-text": "#f9fafb",
+  "--veo-text-secondary": "#d1d5db",
+  "--veo-shadow": "0 20px 60px rgba(0, 0, 0, 0.55)"
+};
+var ALIGN_JUSTIFY = {
+  left: "flex-start",
+  center: "center",
+  right: "flex-end"
+};
+var SHADOW = {
+  none: "none",
+  soft: "0 4px 14px rgba(0, 0, 0, 0.10)",
+  medium: "0 8px 30px rgba(0, 0, 0, 0.18)",
+  strong: "0 24px 60px rgba(0, 0, 0, 0.32)"
+};
+var PRESET_POS = {
+  center: [0.5, 0.5],
+  top: [0.5, 0],
+  bottom: [0.5, 1],
+  left: [0, 0.5],
+  right: [1, 0.5],
+  "top-left": [0, 0],
+  "top-right": [1, 0],
+  "bottom-left": [0, 1],
+  "bottom-right": [1, 1]
+};
+var COLOR_RE = /^#[0-9a-f]{3,8}$|^(rgb|rgba|hsl|hsla)\([\d.,%/\sdeg]+\)$|^[a-z]{3,20}$/i;
+function clamp(n, min, max) {
+  return Math.min(max, Math.max(min, n));
+}
+function applyDesignVars(host, style) {
+  if (!style || typeof style !== "object") return;
+  const s = style;
+  if (typeof s.accentColor === "string" && COLOR_RE.test(s.accentColor.trim())) {
+    host.style.setProperty("--veo-primary", s.accentColor.trim());
+  }
+  if (s.theme === "dark") {
+    for (const [key, value] of Object.entries(DARK_THEME)) {
+      host.style.setProperty(key, value);
+    }
+  }
+  if (typeof s.radius === "number" && Number.isFinite(s.radius)) {
+    host.style.setProperty("--veo-radius", `${clamp(s.radius, 0, 48)}px`);
+  }
+  if (typeof s.width === "number" && Number.isFinite(s.width)) {
+    host.style.setProperty("--veo-width", `${clamp(s.width, 220, 720)}px`);
+  }
+  if (s.align === "left" || s.align === "center" || s.align === "right") {
+    host.style.setProperty("--veo-actions-justify", ALIGN_JUSTIFY[s.align]);
+  }
+  if (typeof s.padding === "number" && Number.isFinite(s.padding)) {
+    host.style.setProperty("--veo-pad", `${clamp(s.padding, 0, 64)}px`);
+  }
+  if (typeof s.margin === "number" && Number.isFinite(s.margin)) {
+    host.style.setProperty("--veo-margin", `${clamp(s.margin, 0, 64)}px`);
+  }
+  if (typeof s.borderWidth === "number" && Number.isFinite(s.borderWidth)) {
+    host.style.setProperty("--veo-border-width", `${clamp(s.borderWidth, 0, 16)}px`);
+  }
+  if (typeof s.borderColor === "string" && COLOR_RE.test(s.borderColor.trim())) {
+    host.style.setProperty("--veo-border-color", s.borderColor.trim());
+  }
+  if (typeof s.shadow === "string" && SHADOW[s.shadow]) {
+    host.style.setProperty("--veo-shadow", SHADOW[s.shadow]);
+  }
+  let px;
+  let py;
+  if (typeof s.posX === "number" && typeof s.posY === "number") {
+    px = clamp(s.posX, 0, 1);
+    py = clamp(s.posY, 0, 1);
+  } else if (typeof s.overlayPosition === "string" && PRESET_POS[s.overlayPosition]) {
+    [px, py] = PRESET_POS[s.overlayPosition];
+  }
+  if (px !== void 0 && py !== void 0) {
+    host.style.setProperty("--veo-pos-x", `${px * 100}%`);
+    host.style.setProperty("--veo-pos-y", `${py * 100}%`);
+  }
+}
+
+// src/plugins/guides/styles.ts
+var GUIDE_STYLES = `
+:host {
+  --veo-primary: #4f46e5;
+  --veo-text: #1f2937;
+  --veo-text-secondary: #4b5563;
+  --veo-bg: #ffffff;
+  --veo-radius: 12px;
+  --veo-shadow: 0 20px 60px rgba(0, 0, 0, 0.25);
+  --veo-width: 420px;
+  --veo-actions-justify: flex-end;
+  all: initial;
+}
+* { box-sizing: border-box; font-family: -apple-system, system-ui, "Segoe UI", Roboto, sans-serif; }
+
+.veo-modal-overlay {
+  position: fixed; inset: 0;
+  background: rgba(15, 15, 30, 0.45);
+  z-index: ${GUIDE_Z_INDEX};
+  animation: veo-fade-in 180ms ease-out;
+}
+/*
+ * Posici\xF3n libre/preset: --veo-pos-x/y son porcentajes (default 50% = centro).
+ * El truco translate(-pos) alinea la MISMA fracci\xF3n de la tarjeta con esa
+ * fracci\xF3n del overlay, as\xED la tarjeta nunca se sale (0% = pegada izquierda,
+ * 100% = pegada derecha, 50% = centrada) sea cual sea su ancho.
+ */
+.veo-modal-card {
+  position: absolute;
+  left: var(--veo-pos-x, 50%);
+  top: var(--veo-pos-y, 50%);
+  transform: translate(calc(var(--veo-pos-x, 50%) * -1), calc(var(--veo-pos-y, 50%) * -1));
+  background: var(--veo-bg);
+  border-radius: var(--veo-radius);
+  border: var(--veo-border-width, 0) solid var(--veo-border-color, transparent);
+  padding: var(--veo-pad, 24px);
+  max-width: var(--veo-width); width: 90%;
+  box-shadow: var(--veo-shadow);
+  animation: veo-fade-in 180ms ease-out;
+}
+
+.veo-banner {
+  position: fixed; left: 0; right: 0;
+  background: var(--veo-bg);
+  border: var(--veo-border-width, 0) solid var(--veo-border-color, transparent);
+  padding: var(--veo-pad, 16px);
+  z-index: ${GUIDE_Z_INDEX};
+  box-shadow: var(--veo-shadow, 0 2px 12px rgba(0, 0, 0, 0.12));
+  animation: veo-slide-down 200ms ease-out;
+}
+.veo-banner-top { top: 0; }
+.veo-banner-bottom { bottom: 0; }
+
+.veo-tooltip {
+  position: absolute;
+  background: var(--veo-bg);
+  border-radius: var(--veo-radius);
+  border: var(--veo-border-width, 0) solid var(--veo-border-color, transparent);
+  padding: var(--veo-pad, 15px);
+  max-width: 300px;
+  z-index: ${GUIDE_Z_INDEX};
+  box-shadow: var(--veo-shadow, 0 8px 30px rgba(0, 0, 0, 0.18));
+  animation: veo-fade-in 150ms ease-out;
+}
+
+.veo-inline {
+  background: var(--veo-bg);
+  border-radius: var(--veo-radius);
+  border: var(--veo-border-width, 0) solid var(--veo-border-color, transparent);
+  padding: var(--veo-pad, 20px);
+  max-width: var(--veo-width);
+  margin: var(--veo-margin, 12px) 0;
+  position: relative;
+  box-shadow: var(--veo-shadow);
+  animation: veo-fade-in 160ms ease-out;
+}
+
+.veo-guide-content {
+  position: relative;
+  display: flex; flex-direction: column;
+}
+.veo-guide-image {
+  display: block; width: 100%; max-height: 180px;
+  object-fit: cover; border-radius: 8px;
+  margin-bottom: 12px;
+}
+.veo-guide-title {
+  font-size: 18px; font-weight: 600; line-height: 1.3;
+  margin: 0 0 6px; color: var(--veo-text);
+}
+.veo-guide-text {
+  font-size: 14px; line-height: 1.5;
+  margin: 0 0 16px; color: var(--veo-text-secondary);
+}
+.veo-guide-actions {
+  display: flex; gap: 8px; justify-content: var(--veo-actions-justify);
+}
+.veo-guide-cta {
+  background: var(--veo-primary); color: #fff; border: none;
+  padding: 9px 18px; border-radius: 8px;
+  font-size: 14px; font-weight: 500; cursor: pointer;
+  transition: opacity 120ms ease;
+}
+.veo-guide-cta:hover { opacity: 0.9; }
+.veo-guide-cta:active { transform: translateY(1px); }
+.veo-guide-close {
+  position: absolute; top: -6px; right: -6px;
+  width: 24px; height: 24px;
+  background: none; border: none;
+  font-size: 22px; line-height: 1;
+  cursor: pointer; color: #9ca3af; padding: 0;
+}
+.veo-guide-close:hover { color: var(--veo-text); }
+
+.veo-form { display: flex; flex-direction: column; gap: 14px; margin-bottom: 16px; }
+.veo-form-field { display: flex; flex-direction: column; gap: 6px; }
+.veo-form-label { font-size: 13px; font-weight: 500; color: var(--veo-text); }
+.veo-form-input {
+  font-size: 14px; color: var(--veo-text);
+  background: var(--veo-bg);
+  border: 1px solid #d1d5db; border-radius: 8px;
+  padding: 8px 10px; width: 100%;
+}
+.veo-form-input:focus { outline: 2px solid var(--veo-primary); outline-offset: -1px; border-color: transparent; }
+.veo-form-options { display: flex; flex-direction: column; gap: 6px; }
+.veo-form-option {
+  display: flex; align-items: center; gap: 8px;
+  font-size: 14px; color: var(--veo-text); cursor: pointer;
+}
+.veo-form-option input { accent-color: var(--veo-primary); margin: 0; cursor: pointer; }
+.veo-form-scale { display: flex; gap: 4px; flex-wrap: wrap; }
+.veo-nps-btn {
+  min-width: 30px; height: 30px; padding: 0 4px;
+  font-size: 13px; font-weight: 500; color: var(--veo-text);
+  background: var(--veo-bg); border: 1px solid #d1d5db; border-radius: 6px;
+  cursor: pointer; transition: all 100ms ease;
+}
+.veo-nps-btn:hover { border-color: var(--veo-primary); }
+.veo-rating-btn {
+  background: none; border: none; padding: 0 2px;
+  font-size: 26px; line-height: 1; color: #d1d5db;
+  cursor: pointer; transition: color 100ms ease;
+}
+.veo-scale-active.veo-nps-btn { background: var(--veo-primary); color: #fff; border-color: var(--veo-primary); }
+.veo-scale-active.veo-rating-btn { color: #f59e0b; }
+.veo-form-error { font-size: 13px; color: #dc2626; margin: 0; }
+.veo-form-thanks {
+  text-align: center; padding: 24px 8px;
+  font-size: 16px; font-weight: 600; color: var(--veo-text);
+}
+.veo-form-preview-note {
+  text-align: center; margin: 0 0 12px;
+  font-size: 12px; color: #b45309;
+}
+
+.veo-walkthrough {
+  position: absolute;
+  background: var(--veo-bg);
+  border-radius: var(--veo-radius);
+  border: var(--veo-border-width, 0) solid var(--veo-border-color, transparent);
+  padding: var(--veo-pad, 16px);
+  max-width: 340px;
+  z-index: ${GUIDE_Z_INDEX};
+  box-shadow: var(--veo-shadow, 0 8px 30px rgba(0, 0, 0, 0.2));
+  animation: veo-fade-in 150ms ease-out;
+}
+.veo-walkthrough-arrow {
+  position: absolute;
+  width: 12px;
+  height: 12px;
+  background: var(--veo-bg);
+  transform: rotate(45deg);
+  pointer-events: none;
+}
+.veo-walkthrough-counter {
+  font-size: 11px; color: #9ca3af;
+  margin-bottom: 8px; letter-spacing: 0.02em;
+}
+.veo-walkthrough-progress {
+  display: flex; gap: 4px;
+  margin-bottom: 12px;
+}
+.veo-walkthrough-progress-dot {
+  width: 8px; height: 8px;
+  border-radius: 50%;
+  background: #e5e7eb;
+  transition: background 200ms ease;
+}
+.veo-walkthrough-progress-dot.active { background: var(--veo-primary); }
+.veo-walkthrough-progress-dot.completed { background: var(--veo-primary); opacity: 0.5; }
+.veo-walkthrough-actions {
+  display: flex; align-items: center;
+  margin-top: 16px; gap: 8px;
+}
+.veo-walkthrough-actions-right {
+  display: flex; gap: 8px;
+  margin-left: auto;
+}
+.veo-walkthrough-btn-secondary {
+  background: transparent; color: #6b7280;
+  border: 1px solid #e5e7eb;
+  padding: 8px 16px; border-radius: 8px;
+  font-size: 13px; cursor: pointer;
+  transition: background 120ms ease;
+}
+.veo-walkthrough-btn-secondary:hover { background: #f9fafb; }
+.veo-walkthrough-skip {
+  background: transparent; color: #9ca3af;
+  border: none; padding: 4px 8px;
+  font-size: 12px; cursor: pointer;
+}
+.veo-walkthrough-skip:hover { color: var(--veo-text); }
+
+.veo-custom-floating {
+  position: fixed;
+  z-index: ${GUIDE_Z_INDEX};
+  max-width: calc(100vw - 16px);
+  max-height: calc(100vh - 16px);
+  animation: veo-fade-in 160ms ease;
+}
+.veo-custom-anchored {
+  position: fixed;
+  top: 0; left: 0;
+  z-index: ${GUIDE_Z_INDEX};
+  max-width: calc(100vw - 16px);
+  animation: veo-fade-in 160ms ease;
+}
+.veo-custom-inline {
+  display: block;
+  margin: 12px 0;
+}
+.veo-custom-frame {
+  display: block;
+  border: 0;
+  width: 360px;
+  background: transparent;
+  color-scheme: normal;
+}
+
+@keyframes veo-fade-in { from { opacity: 0; } to { opacity: 1; } }
+@keyframes veo-slide-up {
+  from { transform: translateY(10px); opacity: 0; }
+  to { transform: translateY(0); opacity: 1; }
+}
+@keyframes veo-slide-down {
+  from { transform: translateY(-10px); opacity: 0; }
+  to { transform: translateY(0); opacity: 1; }
+}
+`;
+
+// src/plugins/guides/renderers/base-renderer.ts
+var BaseRenderer = class {
+  constructor() {
+    this.host = null;
+    this.shadow = null;
+    this.cleanups = [];
+  }
+  /**
+   * Crea un `<div data-veo-guide>` adjunto a `document.body`, le adjunta
+   * un ShadowRoot abierto e inyecta los estilos. Retorna el nodo raíz
+   * donde la subclase puede insertar el contenido específico.
+   */
+  createHost() {
+    const host = document.createElement("div");
+    host.setAttribute(GUIDE_HOST_ATTR, "");
+    const shadow = host.attachShadow({ mode: "open" });
+    const style = document.createElement("style");
+    style.textContent = GUIDE_STYLES;
+    shadow.appendChild(style);
+    const root = document.createElement("div");
+    shadow.appendChild(root);
+    document.body.appendChild(host);
+    this.host = host;
+    this.shadow = shadow;
+    return { host, shadow, root };
+  }
+  /**
+   * Aplica la tematización por datos del step (`step.style`) como variables
+   * CSS sobre el host. Llamar tras `createHost()`. No-op si no hay host o
+   * style. Ver `guide-design.ts`.
+   */
+  applyDesign(style) {
+    if (this.host) applyDesignVars(this.host, style);
+  }
+  /**
+   * Registra una función a ejecutar en `destroy()`. Útil para limpiar
+   * listeners globales (scroll, resize) o intervalos.
+   */
+  registerCleanup(fn) {
+    this.cleanups.push(fn);
+  }
+  /** Remueve el host del DOM y corre todas las funciones de cleanup. */
+  destroy() {
+    for (const fn of this.cleanups) {
+      try {
+        fn();
+      } catch {
+      }
+    }
+    this.cleanups = [];
+    if (this.host?.parentNode) {
+      this.host.parentNode.removeChild(this.host);
+    }
+    this.host = null;
+    this.shadow = null;
+  }
+};
+
+// src/plugins/guides/renderers/banner-renderer.ts
+var BannerRenderer = class extends BaseRenderer {
+  render(context) {
+    const step = context.guide.guideSteps[0];
+    if (!step) return;
+    const { root } = this.createHost();
+    this.applyDesign(step.style);
+    const ownerDocument = root.ownerDocument ?? document;
+    const position = step.style?.position === "bottom" ? "bottom" : "top";
+    const banner = ownerDocument.createElement("div");
+    banner.className = `veo-banner veo-banner-${position}`;
+    const dismiss = (action, ctaUrl) => {
+      context.onInteraction({
+        guideId: context.guide.guideId,
+        stepIndex: 0,
+        action
+      });
+      if (ctaUrl) window.open(ctaUrl, "_blank", "noopener,noreferrer");
+      context.onClose();
+    };
+    const content = buildStepContent(step, ownerDocument, {
+      onCtaClick: (action, url) => {
+        dismiss("cta_clicked", action === "url" ? url : void 0);
+      },
+      onDismiss: () => dismiss("dismissed")
+    });
+    banner.appendChild(content);
+    root.appendChild(banner);
+    context.onInteraction({
+      guideId: context.guide.guideId,
+      stepIndex: 0,
+      action: "shown"
+    });
+  }
+};
+
+// src/plugins/guides/wait-for-element.ts
+function waitForElement(selector, timeoutMs = DEFAULT_ANCHOR_WAIT_MS) {
+  return new Promise((resolve) => {
+    const safeQuery = () => {
+      try {
+        return document.querySelector(selector);
+      } catch {
+        return null;
+      }
+    };
+    const existing = safeQuery();
+    if (existing) {
+      resolve(existing);
+      return;
+    }
+    let resolved = false;
+    const finish = (el) => {
+      if (resolved) return;
+      resolved = true;
+      observer.disconnect();
+      clearTimeout(timer);
+      resolve(el);
+    };
+    const observer = new MutationObserver(() => {
+      const el = safeQuery();
+      if (el) finish(el);
+    });
+    observer.observe(document.body, { childList: true, subtree: true });
+    const timer = setTimeout(() => finish(null), timeoutMs);
+  });
+}
+
+// src/utils/uuid.ts
+function uuidv7() {
+  const timestamp = Date.now();
+  const timeHex = timestamp.toString(16).padStart(12, "0");
+  const random = new Uint8Array(10);
+  if (typeof crypto !== "undefined" && typeof crypto.getRandomValues === "function") {
+    crypto.getRandomValues(random);
+  } else {
+    for (let i = 0; i < random.length; i++) {
+      random[i] = Math.floor(Math.random() * 256);
+    }
+  }
+  random[0] = (random[0] ?? 0) & 15 | 112;
+  random[2] = (random[2] ?? 0) & 63 | 128;
+  const hex = Array.from(random, (b) => b.toString(16).padStart(2, "0")).join("");
+  return [
+    timeHex.slice(0, 8),
+    timeHex.slice(8, 12),
+    hex.slice(0, 4),
+    hex.slice(4, 8),
+    hex.slice(8, 20)
+  ].join("-");
+}
+
+// src/plugins/guides/renderers/custom-frame.ts
+function mountCustomFrame(doc, step, context, opts) {
+  const iframe = doc.createElement("iframe");
+  iframe.className = "veo-custom-frame";
+  iframe.setAttribute("sandbox", "allow-scripts");
+  iframe.setAttribute("title", context.guide.guideName || "Veo");
+  iframe.style.width = opts.width;
+  const hasFixedHeight = opts.fixedHeight !== void 0 && opts.fixedHeight !== null;
+  if (hasFixedHeight) iframe.style.height = toCssSize(opts.fixedHeight);
+  const token = uuidv7();
+  iframe.srcdoc = buildSrcdoc(step.html ?? "", step.css ?? "", step.js ?? "", token);
+  const close = () => context.onClose();
+  const onMessage = (event) => {
+    if (event.source !== iframe.contentWindow) return;
+    const data = event.data;
+    if (!data || typeof data !== "object" || data.__veo !== token) return;
+    switch (data.type) {
+      case "dismiss":
+        context.onInteraction({
+          guideId: context.guide.guideId,
+          stepIndex: 0,
+          action: "dismissed"
+        });
+        close();
+        break;
+      case "cta":
+        context.onInteraction({
+          guideId: context.guide.guideId,
+          stepIndex: 0,
+          action: "cta_clicked"
+        });
+        if (typeof data.url === "string" && isSafeUrl(data.url)) {
+          window.open(data.url, "_blank", "noopener,noreferrer");
+        }
+        if (data.close !== false) close();
+        break;
+      case "navigate":
+        if (typeof data.url === "string" && isSafeUrl(data.url)) {
+          window.location.assign(data.url);
+        }
+        break;
+      case "track":
+        if (typeof data.name === "string" && context.onTrack) {
+          context.onTrack(data.name, isRecord(data.props) ? data.props : void 0);
+        }
+        break;
+      case "resize":
+        if (!hasFixedHeight && typeof data.height === "number" && data.height > 0) {
+          iframe.style.height = `${Math.ceil(data.height)}px`;
+        }
+        break;
+    }
+  };
+  window.addEventListener("message", onMessage);
+  return { iframe, cleanup: () => window.removeEventListener("message", onMessage) };
+}
+function toCssSize(value) {
+  return typeof value === "number" ? `${value}px` : value;
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function buildSrcdoc(html, css, js, token) {
+  const bridge = `(function(){var T=${JSON.stringify(token)};function P(m){m.__veo=T;parent.postMessage(m,'*');}window.veo={dismiss:function(){P({type:'dismiss'});},cta:function(u){P({type:'cta',url:u});},track:function(n,p){P({type:'track',name:n,props:p||{}});},navigate:function(u){P({type:'navigate',url:u});}};document.addEventListener('click',function(e){var a=e.target&&e.target.closest?e.target.closest('a[href]'):null;if(!a)return;var h=a.getAttribute('href');if(!h||h.charAt(0)==='#'||/^(javascript|mailto|tel):/i.test(h))return;e.preventDefault();if(a.target==='_blank'){P({type:'cta',url:a.href,close:false});}else{P({type:'navigate',url:h});}},true);function H(){P({type:'resize',height:Math.ceil(document.documentElement.scrollHeight)});}window.addEventListener('load',H);try{if(typeof ResizeObserver!=='undefined'){new ResizeObserver(H).observe(document.documentElement);}}catch(e){}})();`;
+  return `<!DOCTYPE html><html><head><meta charset="utf-8"><style>html,body{margin:0;padding:0;background:transparent;}</style><style>${escapeClosing(css, "style")}</style></head><body>${html}<script>${bridge}</script>` + (js ? `<script>${escapeClosing(js, "script")}</script>` : "") + "</body></html>";
+}
+function escapeClosing(code, tag) {
+  const rx = tag === "script" ? /<\/script/gi : /<\/style/gi;
+  return code.replace(rx, `<\\/${tag}`);
+}
+
+// src/plugins/guides/renderers/custom-renderer.ts
+var DEFAULT_PLACEMENT = { mode: "floating", position: "bottom-right" };
+var DEFAULT_OFFSET = 16;
+var DEFAULT_WIDTH = 360;
+var CustomRenderer = class extends BaseRenderer {
+  async render(context) {
+    const step = context.guide.guideSteps[0];
+    if (!step || typeof step.html !== "string" || step.html.length === 0) return;
+    const placement = step.placement ?? DEFAULT_PLACEMENT;
+    let anchor = null;
+    if (placement.mode === "anchored") {
+      const selector = placement.selector ?? step.selector ?? context.guide.activationRules.selector;
+      if (typeof selector !== "string" || selector.length === 0) return;
+      anchor = await waitForElement(selector);
+      if (!anchor) return;
+    }
+    const { root } = this.createHost();
+    const doc = root.ownerDocument ?? document;
+    const wrapper = doc.createElement("div");
+    wrapper.className = placement.mode === "anchored" ? "veo-custom-anchored" : "veo-custom-floating";
+    const { iframe, cleanup } = mountCustomFrame(doc, step, context, {
+      width: toCssSize(placement.width ?? DEFAULT_WIDTH),
+      fixedHeight: placement.height ?? null
+    });
+    this.registerCleanup(cleanup);
+    wrapper.appendChild(iframe);
+    root.appendChild(wrapper);
+    if (placement.mode === "floating") {
+      applyFloatingPosition(wrapper, placement);
+    } else if (anchor) {
+      this.registerCleanup(await this.setupAnchoredPosition(anchor, wrapper, placement));
+    }
+    context.onInteraction({ guideId: context.guide.guideId, stepIndex: 0, action: "shown" });
+  }
+  async setupAnchoredPosition(anchor, wrapper, placement) {
+    const side = placement.side ?? "bottom";
+    const update = async () => {
+      const { x, y } = await dom.computePosition(anchor, wrapper, {
+        placement: side,
+        strategy: "fixed",
+        middleware: [dom.offset(placement.offsetY ?? 8), dom.flip(), dom.shift({ padding: 8 })]
+      });
+      wrapper.style.left = `${x}px`;
+      wrapper.style.top = `${y}px`;
+    };
+    await update();
+    const reposition = () => {
+      void update();
+    };
+    window.addEventListener("scroll", reposition, true);
+    window.addEventListener("resize", reposition);
+    return () => {
+      window.removeEventListener("scroll", reposition, true);
+      window.removeEventListener("resize", reposition);
+    };
+  }
+};
+function applyFloatingPosition(wrapper, placement) {
+  const position = placement.position ?? "bottom-right";
+  const ox = `${placement.offsetX ?? DEFAULT_OFFSET}px`;
+  const oy = `${placement.offsetY ?? DEFAULT_OFFSET}px`;
+  const s = wrapper.style;
+  if (position === "center") {
+    s.top = "50%";
+    s.left = "50%";
+    s.transform = "translate(-50%, -50%)";
+    return;
+  }
+  const [vertical, horizontal] = position.split("-");
+  if (vertical === "top") s.top = oy;
+  else s.bottom = oy;
+  if (horizontal === "left") {
+    s.left = ox;
+  } else if (horizontal === "right") {
+    s.right = ox;
+  } else {
+    s.left = "50%";
+    s.transform = "translateX(-50%)";
+  }
+}
+
+// src/plugins/guides/form-content.ts
+function mountFormContent(card, context, doc) {
+  const step = context.guide.guideSteps[0];
+  if (!step) return;
+  const fields = step.fields ?? [];
+  const dismiss = () => {
+    context.onInteraction({ guideId: context.guide.guideId, stepIndex: 0, action: "dismissed" });
+    context.onClose();
+  };
+  const content = doc.createElement("div");
+  content.className = "veo-guide-content";
+  if (step.title) {
+    const heading = doc.createElement("h2");
+    heading.className = "veo-guide-title";
+    heading.textContent = step.title;
+    content.appendChild(heading);
+  }
+  if (step.content) {
+    const paragraph = doc.createElement("p");
+    paragraph.className = "veo-guide-text";
+    paragraph.textContent = step.content;
+    content.appendChild(paragraph);
+  }
+  const readers = [];
+  const form = doc.createElement("form");
+  form.className = "veo-form";
+  form.noValidate = true;
+  for (const field of fields) {
+    const { wrapper, read } = buildField(field, doc);
+    readers.push({ field, read });
+    form.appendChild(wrapper);
+  }
+  const error = doc.createElement("p");
+  error.className = "veo-form-error";
+  error.style.display = "none";
+  form.appendChild(error);
+  const actions = doc.createElement("div");
+  actions.className = "veo-guide-actions";
+  const submit = doc.createElement("button");
+  submit.type = "submit";
+  submit.className = "veo-guide-cta";
+  submit.textContent = step.ctaText || "Enviar";
+  actions.appendChild(submit);
+  form.appendChild(actions);
+  form.addEventListener("submit", (e) => {
+    e.preventDefault();
+    error.style.display = "none";
+    const answers = {};
+    for (const { field, read } of readers) {
+      const value = read();
+      const empty = value === void 0 || value === null || value === "";
+      if (empty) {
+        if (field.required) {
+          error.textContent = `Complet\xE1 "${field.label}"`;
+          error.style.display = "block";
+          return;
+        }
+        continue;
+      }
+      answers[field.key] = value;
+    }
+    if (Object.keys(answers).length === 0) {
+      error.textContent = "Respond\xE9 al menos un campo";
+      error.style.display = "block";
+      return;
+    }
+    submit.disabled = true;
+    const submitFn = context.onFormSubmit ?? (() => Promise.resolve(true));
+    void submitFn(answers).then((ok) => {
+      if (!ok) {
+        submit.disabled = false;
+        error.textContent = "No se pudo enviar. Prob\xE1 de nuevo.";
+        error.style.display = "block";
+        return;
+      }
+      context.onInteraction({ guideId: context.guide.guideId, stepIndex: 0, action: "completed" });
+      const note = context.isPreview ? context.previewNote ?? "Vista previa: la respuesta NO se guard\xF3." : null;
+      showThanks(card, doc, note);
+      window.setTimeout(() => context.onClose(), note ? 2200 : 1400);
+    });
+  });
+  content.appendChild(form);
+  const closeBtn = doc.createElement("button");
+  closeBtn.type = "button";
+  closeBtn.className = "veo-guide-close";
+  closeBtn.setAttribute("aria-label", "Cerrar");
+  closeBtn.textContent = "\xD7";
+  closeBtn.addEventListener("click", dismiss);
+  content.appendChild(closeBtn);
+  card.appendChild(content);
+}
+function showThanks(card, doc, note) {
+  while (card.firstChild) card.removeChild(card.firstChild);
+  const thanks = doc.createElement("div");
+  thanks.className = "veo-form-thanks";
+  thanks.textContent = "\u2713 \xA1Gracias por tu respuesta!";
+  card.appendChild(thanks);
+  if (note) {
+    const noteEl = doc.createElement("p");
+    noteEl.className = "veo-form-preview-note";
+    noteEl.textContent = note;
+    card.appendChild(noteEl);
+  }
+}
+function buildField(field, doc) {
+  const wrapper = doc.createElement("div");
+  wrapper.className = "veo-form-field";
+  const label = doc.createElement("label");
+  label.className = "veo-form-label";
+  label.textContent = field.required ? `${field.label} *` : field.label;
+  wrapper.appendChild(label);
+  switch (field.type) {
+    case "textarea": {
+      const input = doc.createElement("textarea");
+      input.className = "veo-form-input";
+      input.rows = 3;
+      if (field.placeholder) input.placeholder = field.placeholder;
+      wrapper.appendChild(input);
+      return { wrapper, read: () => input.value.trim() };
+    }
+    case "number": {
+      const input = doc.createElement("input");
+      input.type = "number";
+      input.className = "veo-form-input";
+      if (field.placeholder) input.placeholder = field.placeholder;
+      wrapper.appendChild(input);
+      return {
+        wrapper,
+        read: () => input.value.trim() === "" ? void 0 : Number(input.value)
+      };
+    }
+    case "select": {
+      const select = doc.createElement("select");
+      select.className = "veo-form-input";
+      const blank = doc.createElement("option");
+      blank.value = "";
+      blank.textContent = field.placeholder || "Eleg\xED una opci\xF3n\u2026";
+      select.appendChild(blank);
+      for (const opt of field.options ?? []) {
+        const option = doc.createElement("option");
+        option.value = opt;
+        option.textContent = opt;
+        select.appendChild(option);
+      }
+      wrapper.appendChild(select);
+      return { wrapper, read: () => select.value || void 0 };
+    }
+    case "radio": {
+      const group = doc.createElement("div");
+      group.className = "veo-form-options";
+      const name = `veo-${field.key}`;
+      const inputs = [];
+      for (const opt of field.options ?? []) {
+        const optionLabel = doc.createElement("label");
+        optionLabel.className = "veo-form-option";
+        const radio = doc.createElement("input");
+        radio.type = "radio";
+        radio.name = name;
+        radio.value = opt;
+        inputs.push(radio);
+        const text = doc.createElement("span");
+        text.textContent = opt;
+        optionLabel.appendChild(radio);
+        optionLabel.appendChild(text);
+        group.appendChild(optionLabel);
+      }
+      wrapper.appendChild(group);
+      return { wrapper, read: () => inputs.find((i) => i.checked)?.value };
+    }
+    case "multiselect": {
+      const group = doc.createElement("div");
+      group.className = "veo-form-options";
+      const inputs = [];
+      for (const opt of field.options ?? []) {
+        const optionLabel = doc.createElement("label");
+        optionLabel.className = "veo-form-option";
+        const checkbox = doc.createElement("input");
+        checkbox.type = "checkbox";
+        checkbox.value = opt;
+        inputs.push(checkbox);
+        const text = doc.createElement("span");
+        text.textContent = opt;
+        optionLabel.appendChild(checkbox);
+        optionLabel.appendChild(text);
+        group.appendChild(optionLabel);
+      }
+      wrapper.appendChild(group);
+      return {
+        wrapper,
+        read: () => {
+          const values = inputs.filter((i) => i.checked).map((i) => i.value);
+          return values.length > 0 ? values : void 0;
+        }
+      };
+    }
+    case "checkbox": {
+      const optionLabel = doc.createElement("label");
+      optionLabel.className = "veo-form-option";
+      const checkbox = doc.createElement("input");
+      checkbox.type = "checkbox";
+      const text = doc.createElement("span");
+      text.textContent = field.placeholder || "S\xED";
+      optionLabel.appendChild(checkbox);
+      optionLabel.appendChild(text);
+      wrapper.appendChild(optionLabel);
+      return { wrapper, read: () => checkbox.checked ? true : field.required ? "" : false };
+    }
+    case "yesno": {
+      const group = doc.createElement("div");
+      group.className = "veo-form-options";
+      const name = `veo-${field.key}`;
+      const [yesLabel, noLabel] = field.options?.length === 2 ? field.options : ["S\xED", "No"];
+      const inputs = [];
+      for (const { label: optText, value } of [
+        { label: yesLabel, value: true },
+        { label: noLabel, value: false }
+      ]) {
+        const optionLabel = doc.createElement("label");
+        optionLabel.className = "veo-form-option";
+        const radio = doc.createElement("input");
+        radio.type = "radio";
+        radio.name = name;
+        inputs.push({ input: radio, value });
+        const text = doc.createElement("span");
+        text.textContent = optText;
+        optionLabel.appendChild(radio);
+        optionLabel.appendChild(text);
+        group.appendChild(optionLabel);
+      }
+      wrapper.appendChild(group);
+      return { wrapper, read: () => inputs.find((i) => i.input.checked)?.value };
+    }
+    case "nps":
+      return buildScale(wrapper, doc, 0, 10, "veo-nps-btn");
+    case "rating":
+      return buildScale(wrapper, doc, 1, 5, "veo-rating-btn", "\u2605");
+    default: {
+      const input = doc.createElement("input");
+      input.type = "text";
+      input.className = "veo-form-input";
+      if (field.placeholder) input.placeholder = field.placeholder;
+      wrapper.appendChild(input);
+      return { wrapper, read: () => input.value.trim() };
+    }
+  }
+}
+function buildScale(wrapper, doc, min, max, btnClass, symbol) {
+  const row = doc.createElement("div");
+  row.className = "veo-form-scale";
+  let selected;
+  const buttons = [];
+  for (let n = min; n <= max; n++) {
+    const btn = doc.createElement("button");
+    btn.type = "button";
+    btn.className = btnClass;
+    btn.textContent = symbol ?? String(n);
+    btn.setAttribute("aria-label", String(n));
+    btn.addEventListener("click", () => {
+      selected = n;
+      buttons.forEach((b, i) => {
+        const active = symbol ? i + min <= n : i + min === n;
+        b.classList.toggle("veo-scale-active", active);
+      });
+    });
+    buttons.push(btn);
+    row.appendChild(btn);
+  }
+  wrapper.appendChild(row);
+  return { wrapper, read: () => selected };
+}
+
+// src/plugins/guides/renderers/form-renderer.ts
+var FormRenderer = class extends BaseRenderer {
+  render(context) {
+    const step = context.guide.guideSteps[0];
+    if (!step || (step.fields ?? []).length === 0) return;
+    const { root } = this.createHost();
+    this.applyDesign(step.style);
+    const doc = root.ownerDocument ?? document;
+    const overlay = doc.createElement("div");
+    overlay.className = "veo-modal-overlay";
+    const card = doc.createElement("div");
+    card.className = "veo-modal-card";
+    mountFormContent(card, context, doc);
+    overlay.appendChild(card);
+    root.appendChild(overlay);
+    const dismiss = () => {
+      context.onInteraction({ guideId: context.guide.guideId, stepIndex: 0, action: "dismissed" });
+      context.onClose();
+    };
+    overlay.addEventListener("click", (e) => {
+      if (e.target === overlay) dismiss();
+    });
+    const onKey = (e) => {
+      if (e.key === "Escape") dismiss();
+    };
+    document.addEventListener("keydown", onKey);
+    this.registerCleanup(() => document.removeEventListener("keydown", onKey));
+    context.onInteraction({ guideId: context.guide.guideId, stepIndex: 0, action: "shown" });
+  }
+};
+
+// src/plugins/guides/inline-host.ts
+function readInlinePosition(style) {
+  const p = style?.inlinePosition;
+  return p === "before" || p === "prepend" || p === "append" ? p : "after";
+}
+function insertHost(anchor, host, position) {
+  switch (position) {
+    case "before":
+      anchor.before(host);
+      break;
+    case "after":
+      anchor.after(host);
+      break;
+    case "prepend":
+      anchor.prepend(host);
+      break;
+    case "append":
+      anchor.append(host);
+      break;
+  }
+}
+function keepHostAttached(host, selector, position) {
+  const id = window.setInterval(() => {
+    if (host.isConnected) return;
+    const anchor = document.querySelector(selector);
+    if (anchor) insertHost(anchor, host, position);
+  }, 1e3);
+  return () => window.clearInterval(id);
+}
+
+// src/plugins/guides/renderers/inline-custom-renderer.ts
+var InlineCustomRenderer = class extends BaseRenderer {
+  async render(context) {
+    const step = context.guide.guideSteps[0];
+    if (!step || typeof step.html !== "string" || step.html.length === 0) return;
+    const selector = step.selector ?? context.guide.activationRules.selector;
+    if (typeof selector !== "string" || selector.length === 0) return;
+    const anchor = await waitForElement(selector);
+    if (!anchor) return;
+    const { host, root } = this.createHost();
+    host.style.display = "block";
+    const position = readInlinePosition(step.style);
+    insertHost(anchor, host, position);
+    this.registerCleanup(keepHostAttached(host, selector, position));
+    const doc = root.ownerDocument ?? document;
+    const wrapper = doc.createElement("div");
+    wrapper.className = "veo-custom-inline";
+    const { iframe, cleanup } = mountCustomFrame(doc, step, context, { width: "100%" });
+    this.registerCleanup(cleanup);
+    wrapper.appendChild(iframe);
+    root.appendChild(wrapper);
+    context.onInteraction({ guideId: context.guide.guideId, stepIndex: 0, action: "shown" });
+  }
+};
+
+// src/plugins/guides/renderers/inline-form-renderer.ts
+var InlineFormRenderer = class extends BaseRenderer {
+  async render(context) {
+    const step = context.guide.guideSteps[0];
+    if (!step || (step.fields ?? []).length === 0) return;
+    const selector = step.selector ?? context.guide.activationRules.selector;
+    if (typeof selector !== "string" || selector.length === 0) return;
+    const anchor = await waitForElement(selector);
+    if (!anchor) return;
+    const { host, root } = this.createHost();
+    host.style.display = "block";
+    const position = readInlinePosition(step.style);
+    insertHost(anchor, host, position);
+    this.registerCleanup(keepHostAttached(host, selector, position));
+    this.applyDesign(step.style);
+    const doc = root.ownerDocument ?? document;
+    const card = doc.createElement("div");
+    card.className = "veo-inline";
+    mountFormContent(card, context, doc);
+    root.appendChild(card);
+    context.onInteraction({ guideId: context.guide.guideId, stepIndex: 0, action: "shown" });
+  }
+};
+
+// src/plugins/guides/renderers/inline-renderer.ts
+var InlineRenderer = class extends BaseRenderer {
+  async render(context) {
+    const step = context.guide.guideSteps[0];
+    if (!step) return;
+    const selector = step.selector ?? context.guide.activationRules.selector;
+    if (typeof selector !== "string" || selector.length === 0) return;
+    const anchor = await waitForElement(selector);
+    if (!anchor) return;
+    const { host, root } = this.createHost();
+    host.style.display = "block";
+    const position = readInlinePosition(step.style);
+    insertHost(anchor, host, position);
+    this.registerCleanup(keepHostAttached(host, selector, position));
+    this.applyDesign(step.style);
+    const ownerDocument = root.ownerDocument ?? document;
+    const card = ownerDocument.createElement("div");
+    card.className = "veo-inline";
+    const dismiss = (action, ctaUrl) => {
+      context.onInteraction({ guideId: context.guide.guideId, stepIndex: 0, action });
+      if (ctaUrl) window.open(ctaUrl, "_blank", "noopener,noreferrer");
+      context.onClose();
+    };
+    const content = buildStepContent(step, ownerDocument, {
+      onCtaClick: (action, url) => dismiss("cta_clicked", action === "url" ? url : void 0),
+      onDismiss: () => dismiss("dismissed")
+    });
+    card.appendChild(content);
+    root.appendChild(card);
+    context.onInteraction({ guideId: context.guide.guideId, stepIndex: 0, action: "shown" });
+  }
+};
+
+// src/plugins/guides/renderers/modal-renderer.ts
+var ModalRenderer = class extends BaseRenderer {
+  render(context) {
+    const step = context.guide.guideSteps[0];
+    if (!step) return;
+    const { root } = this.createHost();
+    this.applyDesign(step.style);
+    const ownerDocument = root.ownerDocument ?? document;
+    const overlay = ownerDocument.createElement("div");
+    overlay.className = "veo-modal-overlay";
+    const card = ownerDocument.createElement("div");
+    card.className = "veo-modal-card";
+    const dismiss = (action, ctaUrl) => {
+      context.onInteraction({
+        guideId: context.guide.guideId,
+        stepIndex: 0,
+        action
+      });
+      if (ctaUrl) window.open(ctaUrl, "_blank", "noopener,noreferrer");
+      context.onClose();
+    };
+    const content = buildStepContent(step, ownerDocument, {
+      onCtaClick: (action, url) => {
+        dismiss("cta_clicked", action === "url" ? url : void 0);
+      },
+      onDismiss: () => dismiss("dismissed")
+    });
+    card.appendChild(content);
+    overlay.appendChild(card);
+    root.appendChild(overlay);
+    overlay.addEventListener("click", (e) => {
+      if (e.target === overlay) dismiss("dismissed");
+    });
+    const onKey = (e) => {
+      if (e.key === "Escape") dismiss("dismissed");
+    };
+    document.addEventListener("keydown", onKey);
+    this.registerCleanup(() => document.removeEventListener("keydown", onKey));
+    context.onInteraction({
+      guideId: context.guide.guideId,
+      stepIndex: 0,
+      action: "shown"
+    });
+  }
+};
+var TooltipRenderer = class extends BaseRenderer {
+  async render(context) {
+    const step = context.guide.guideSteps[0];
+    if (!step) return;
+    const selector = step.selector ?? context.guide.activationRules.selector;
+    if (typeof selector !== "string" || selector.length === 0) return;
+    const anchor = await waitForElement(selector);
+    if (!anchor) return;
+    const { root } = this.createHost();
+    this.applyDesign(step.style);
+    const ownerDocument = root.ownerDocument ?? document;
+    const tooltip = ownerDocument.createElement("div");
+    tooltip.className = "veo-tooltip";
+    const dismiss = (action, ctaUrl) => {
+      context.onInteraction({
+        guideId: context.guide.guideId,
+        stepIndex: 0,
+        action
+      });
+      if (ctaUrl) window.open(ctaUrl, "_blank", "noopener,noreferrer");
+      context.onClose();
+    };
+    const content = buildStepContent(step, ownerDocument, {
+      onCtaClick: (action, url) => {
+        dismiss("cta_clicked", action === "url" ? url : void 0);
+      },
+      onDismiss: () => dismiss("dismissed")
+    });
+    tooltip.appendChild(content);
+    root.appendChild(tooltip);
+    const updatePosition = async () => {
+      const { x, y } = await dom.computePosition(anchor, tooltip, {
+        placement: "bottom",
+        middleware: [dom.offset(8), dom.flip(), dom.shift({ padding: 8 })]
+      });
+      tooltip.style.left = `${x}px`;
+      tooltip.style.top = `${y}px`;
+    };
+    await updatePosition();
+    const reposition = () => {
+      void updatePosition();
+    };
+    window.addEventListener("scroll", reposition, true);
+    window.addEventListener("resize", reposition);
+    this.registerCleanup(() => {
+      window.removeEventListener("scroll", reposition, true);
+      window.removeEventListener("resize", reposition);
+    });
+    context.onInteraction({
+      guideId: context.guide.guideId,
+      stepIndex: 0,
+      action: "shown"
+    });
+  }
+};
+
+// src/plugins/guides/walkthrough-block-builder.ts
+function buildWalkthroughStepContent(step, stepIndex, totalSteps, doc, callbacks) {
+  const container = doc.createElement("div");
+  container.className = "veo-guide-content";
+  const counter = doc.createElement("div");
+  counter.className = "veo-walkthrough-counter";
+  counter.textContent = `Paso ${stepIndex + 1} de ${totalSteps}`;
+  container.appendChild(counter);
+  const progress = doc.createElement("div");
+  progress.className = "veo-walkthrough-progress";
+  for (let i = 0; i < totalSteps; i++) {
+    const dot = doc.createElement("span");
+    dot.className = "veo-walkthrough-progress-dot";
+    if (i < stepIndex) dot.classList.add("completed");
+    if (i === stepIndex) dot.classList.add("active");
+    progress.appendChild(dot);
+  }
+  container.appendChild(progress);
+  if (typeof step.imageUrl === "string" && step.imageUrl && isSafeUrl(step.imageUrl)) {
+    const img = doc.createElement("img");
+    img.className = "veo-guide-image";
+    img.src = step.imageUrl;
+    img.alt = typeof step.title === "string" ? step.title : "";
+    container.appendChild(img);
+  }
+  if (typeof step.title === "string" && step.title) {
+    const heading = doc.createElement("h2");
+    heading.className = "veo-guide-title";
+    heading.textContent = step.title;
+    container.appendChild(heading);
+  }
+  if (typeof step.content === "string" && step.content) {
+    const paragraph = doc.createElement("p");
+    paragraph.className = "veo-guide-text";
+    paragraph.textContent = step.content;
+    container.appendChild(paragraph);
+  }
+  const actions = doc.createElement("div");
+  actions.className = "veo-walkthrough-actions";
+  const skipBtn = doc.createElement("button");
+  skipBtn.type = "button";
+  skipBtn.className = "veo-walkthrough-skip";
+  skipBtn.textContent = "Omitir";
+  skipBtn.addEventListener("click", () => callbacks.onSkip());
+  actions.appendChild(skipBtn);
+  const rightGroup = doc.createElement("div");
+  rightGroup.className = "veo-walkthrough-actions-right";
+  if (stepIndex > 0) {
+    const backBtn = doc.createElement("button");
+    backBtn.type = "button";
+    backBtn.className = "veo-walkthrough-btn-secondary";
+    backBtn.textContent = "Atr\xE1s";
+    backBtn.addEventListener("click", () => callbacks.onBack());
+    rightGroup.appendChild(backBtn);
+  }
+  const isLastStep = stepIndex === totalSteps - 1;
+  const primaryBtn = doc.createElement("button");
+  primaryBtn.type = "button";
+  primaryBtn.className = "veo-guide-cta";
+  const defaultLabel = isLastStep ? "Finalizar" : "Siguiente";
+  primaryBtn.textContent = typeof step.ctaText === "string" && step.ctaText ? step.ctaText : defaultLabel;
+  primaryBtn.addEventListener("click", () => {
+    if (isLastStep) callbacks.onComplete();
+    else callbacks.onNext();
+  });
+  rightGroup.appendChild(primaryBtn);
+  actions.appendChild(rightGroup);
+  container.appendChild(actions);
+  return container;
+}
+
+// src/plugins/guides/renderers/walkthrough-renderer.ts
+var WalkthroughRenderer = class extends BaseRenderer {
+  async render(context) {
+    const step = context.guide.guideSteps[context.currentStepIndex];
+    if (!step) return false;
+    const selector = step.selector ?? context.guide.activationRules.selector;
+    if (typeof selector !== "string" || selector.length === 0) return false;
+    const anchor = await waitForElement(selector, WALKTHROUGH_STEP_SELECTOR_TIMEOUT_MS);
+    if (!anchor) return false;
+    const { root } = this.createHost();
+    this.applyDesign(step.style);
+    const ownerDocument = root.ownerDocument ?? document;
+    const tooltip = ownerDocument.createElement("div");
+    tooltip.className = "veo-walkthrough";
+    const content = buildWalkthroughStepContent(
+      step,
+      context.currentStepIndex,
+      context.guide.guideSteps.length,
+      ownerDocument,
+      context.callbacks
+    );
+    tooltip.appendChild(content);
+    const arrowEl = ownerDocument.createElement("div");
+    arrowEl.className = "veo-walkthrough-arrow";
+    tooltip.appendChild(arrowEl);
+    root.appendChild(tooltip);
+    const updatePosition = async () => {
+      const { x, y, placement, middlewareData } = await dom.computePosition(anchor, tooltip, {
+        placement: "bottom",
+        middleware: [dom.offset(10), dom.flip(), dom.shift({ padding: 8 }), dom.arrow({ element: arrowEl })]
+      });
+      tooltip.style.left = `${x}px`;
+      tooltip.style.top = `${y}px`;
+      positionArrow(arrowEl, placement, middlewareData.arrow);
+    };
+    await updatePosition();
+    const reposition = () => {
+      void updatePosition();
+    };
+    window.addEventListener("scroll", reposition, true);
+    window.addEventListener("resize", reposition);
+    this.registerCleanup(() => {
+      window.removeEventListener("scroll", reposition, true);
+      window.removeEventListener("resize", reposition);
+    });
+    return true;
+  }
+};
+var STATIC_SIDE = {
+  top: "bottom",
+  bottom: "top",
+  left: "right",
+  right: "left"
+};
+function positionArrow(arrowEl, placement, data) {
+  const side = STATIC_SIDE[placement.split("-")[0] ?? "bottom"] ?? "top";
+  for (const prop of ["top", "bottom", "left", "right"]) {
+    arrowEl.style.setProperty(prop, "");
+  }
+  if (data?.x != null) arrowEl.style.setProperty("left", `${data.x}px`);
+  if (data?.y != null) arrowEl.style.setProperty("top", `${data.y}px`);
+  arrowEl.style.setProperty(side, "-6px");
+}
+
+// src/plugins/guides/guide-preview.ts
+var PREVIEW_GUIDE_ID = "__veo_preview__";
+var GuidePreviewController = class {
+  constructor() {
+    this.singleStep = null;
+    this.walkthrough = null;
+    this.walkthroughGuide = null;
+    this.walkthroughIndex = 0;
+    /** Input de la preview ACTIVA (para formSubmit/nota de forms). */
+    this.input = null;
+  }
+  preview(input) {
+    this.close();
+    this.input = input;
+    const guide = normalize(input);
+    const start = typeof input.startStepIndex === "number" ? input.startStepIndex : 0;
+    const ready = guide.guideType === "walkthrough" ? this.startWalkthrough(guide, start) : this.renderSingleStep(guide);
+    return { close: () => this.close(), ready };
+  }
+  close() {
+    if (this.singleStep) {
+      safeDestroy(this.singleStep);
+      this.singleStep = null;
+    }
+    if (this.walkthrough) {
+      safeDestroy(this.walkthrough);
+      this.walkthrough = null;
+    }
+    this.walkthroughGuide = null;
+    this.walkthroughIndex = 0;
+    this.input = null;
+  }
+  async renderSingleStep(guide) {
+    const renderer = createSingleStepRenderer(guide.guideType);
+    if (!renderer) return { rendered: false };
+    this.singleStep = renderer;
+    let shown = false;
+    try {
+      await renderer.render({
+        guide,
+        onInteraction: (event) => {
+          if (event.action === "shown") shown = true;
+        },
+        onClose: () => this.close(),
+        onTrack: () => {
+        },
+        // Preview de forms: por defecto simula el envío SIN escribir props;
+        // el caller puede pasar `formSubmit` real (link de preview).
+        onFormSubmit: this.input?.formSubmit ?? (() => Promise.resolve(true)),
+        isPreview: true,
+        ...this.input?.formSubmit && this.input.formSubmitNote !== void 0 ? { previewNote: this.input.formSubmitNote } : {}
+      });
+    } catch {
+      this.close();
+      return { rendered: false };
+    }
+    if (this.singleStep !== renderer) {
+      safeDestroy(renderer);
+      return { rendered: false };
+    }
+    return { rendered: shown };
+  }
+  async startWalkthrough(guide, startIndex = 0) {
+    if (guide.guideSteps.length === 0) return { rendered: false };
+    this.walkthroughGuide = guide;
+    const idx = Math.min(Math.max(0, Math.floor(startIndex)), guide.guideSteps.length - 1);
+    this.walkthroughIndex = idx;
+    const rendered = await this.renderWalkthroughStep(idx);
+    return { rendered };
+  }
+  async renderWalkthroughStep(index) {
+    const guide = this.walkthroughGuide;
+    if (!guide) return false;
+    if (this.walkthrough) {
+      safeDestroy(this.walkthrough);
+      this.walkthrough = null;
+    }
+    const renderer = new WalkthroughRenderer();
+    const callbacks = {
+      onNext: () => {
+        const next = this.walkthroughIndex + 1;
+        if (next >= guide.guideSteps.length) {
+          this.close();
+          return;
+        }
+        this.walkthroughIndex = next;
+        void this.renderWalkthroughStep(next);
+      },
+      onBack: () => {
+        const prev = this.walkthroughIndex - 1;
+        if (prev < 0) return;
+        this.walkthroughIndex = prev;
+        void this.renderWalkthroughStep(prev);
+      },
+      onSkip: () => this.close(),
+      onComplete: () => this.close()
+    };
+    let success = false;
+    try {
+      success = await renderer.render({ guide, currentStepIndex: index, callbacks });
+    } catch {
+      success = false;
+    }
+    if (!success || this.walkthroughGuide !== guide) {
+      safeDestroy(renderer);
+      return false;
+    }
+    this.walkthrough = renderer;
+    return true;
+  }
+};
+var activeController = null;
+function previewGuide(input) {
+  if (!hasDocument()) {
+    return { close: () => {
+    }, ready: Promise.resolve({ rendered: false }) };
+  }
+  if (!activeController) activeController = new GuidePreviewController();
+  return activeController.preview(input);
+}
+function closeGuidePreview() {
+  activeController?.close();
+}
+function normalize(input) {
+  const selector = input.activationRules?.selector;
+  const activationRules = {
+    url: input.activationRules?.url ?? { type: "prefix", pattern: "/" },
+    trigger: "immediate",
+    ...selector !== void 0 ? { selector } : {}
+  };
+  return {
+    guideId: PREVIEW_GUIDE_ID,
+    guideName: input.guideName ?? "Preview",
+    guideType: input.guideType,
+    guideSteps: input.guideSteps,
+    activationRules,
+    displayFrequency: "always",
+    displayPriority: 0
+  };
+}
+function 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;
+  }
+}
+function safeDestroy(renderer) {
+  try {
+    renderer.destroy();
+  } catch {
+  }
+}
+
+// src/plugins/builder/bridge-protocol.ts
+var VEO_BUILDER_SOURCE = "veo-builder";
+var BUILDER_TOKEN_PARAM = "veoBuilder";
+var BUILDER_ORIGIN_PARAM = "veoBuilderOrigin";
+
+// src/plugins/autocapture/constants.ts
+var HASHED_CLASS_PATTERNS = [
+  /^css-[a-z0-9]{4,}$/i,
+  // emotion, styled-components nuevas
+  /^_[a-z0-9]+_[a-z0-9]{4,}_\d+$/,
+  // CSS Modules con hash
+  /^[a-z]{2,4}-[a-z0-9]{6,}$/i,
+  // Tailwind JIT (a veces)
+  /^[a-f0-9]{6,}$/i,
+  // hashes hex puros
+  /^sc-[a-z0-9]+$/i
+  // styled-components legacy
+];
+
+// src/plugins/autocapture/selector-builder.ts
+function isHashedClass(className) {
+  return HASHED_CLASS_PATTERNS.some((pattern) => pattern.test(className));
+}
+function filterHumanClasses(element) {
+  return Array.from(element.classList).filter((c) => !isHashedClass(c) && c.length < 64);
+}
+var STABLE_ATTRIBUTES = [
+  "data-testid",
+  "data-test",
+  "data-cy",
+  "name",
+  "aria-label",
+  "placeholder",
+  "alt",
+  "title",
+  // `href` identifica muy bien a los links (`<a>`), un target frecuente de
+  // autocapture; va después de los atributos semánticos pero antes de los
+  // genéricos. Valores largos (URLs absolutas con query) se descartan por
+  // MAX_ATTR_VALUE_LENGTH.
+  "href",
+  "role",
+  "type"
+];
+var MAX_ATTR_VALUE_LENGTH = 100;
+function cssEscape(value) {
+  if (typeof CSS !== "undefined" && typeof CSS.escape === "function") {
+    return CSS.escape(value);
+  }
+  return value.replace(/[!"#$%&'()*+,./:;<=>?@[\\\]^`{|}~]/g, "\\$&");
+}
+function escapeAttrValue(value) {
+  return value.replace(/[\\"]/g, "\\$&");
+}
+function stableAttributeSelector(element, tag) {
+  for (const attr of STABLE_ATTRIBUTES) {
+    const value = element.getAttribute(attr);
+    if (value && value.length > 0 && value.length <= MAX_ATTR_VALUE_LENGTH) {
+      return `${tag}[${attr}="${escapeAttrValue(value)}"]`;
+    }
+  }
+  return null;
+}
+function buildElementSelector(element) {
+  const tag = element.tagName.toLowerCase();
+  const veoTag = element.getAttribute("data-veo-tag");
+  if (veoTag) {
+    return `${tag}[data-veo-tag="${escapeAttrValue(veoTag)}"]`;
+  }
+  if (element.id) {
+    const classes2 = filterHumanClasses(element);
+    const classPart2 = classes2.length > 0 ? `.${classes2.map(cssEscape).join(".")}` : "";
+    return `${tag}#${cssEscape(element.id)}${classPart2}`;
+  }
+  const attrSelector = stableAttributeSelector(element, tag);
+  if (attrSelector) return attrSelector;
+  const classes = filterHumanClasses(element);
+  const classPart = classes.length > 0 ? `.${classes.map(cssEscape).join(".")}` : "";
+  return `${tag}${classPart}`;
+}
+function buildSelectorPath(element, maxAncestors = 5) {
+  const parts = [];
+  let current = element;
+  let depth = 0;
+  while (current && current !== document.documentElement && depth <= maxAncestors) {
+    parts.unshift(buildElementSelector(current));
+    current = current.parentElement;
+    depth++;
+  }
+  return parts.join(" > ");
+}
+
+// src/plugins/builder/element-picker.ts
+var PICKER_Z = 2147483646;
+var PICKER_HOST_ATTR = "data-veo-picker";
+var DEFAULT_MAX_ANCESTORS = 5;
+var PICKER_STYLES = `
+:host { all: initial; }
+.veo-pick-box {
+  position: fixed;
+  z-index: ${PICKER_Z};
+  pointer-events: none;
+  box-sizing: border-box;
+  background: rgba(99, 102, 241, 0.22);
+  border: 1px dashed rgba(99, 102, 241, 0.95);
+  border-radius: 2px;
+  transition: top 60ms ease-out, left 60ms ease-out, width 60ms ease-out, height 60ms ease-out;
+}
+.veo-pick-label {
+  position: fixed;
+  z-index: ${PICKER_Z};
+  pointer-events: none;
+  max-width: 360px;
+  background: #1e1b4b;
+  color: #e0e7ff;
+  font: 12px/1.45 ui-monospace, SFMono-Regular, Menlo, monospace;
+  padding: 6px 9px;
+  border-radius: 6px;
+  box-shadow: 0 6px 20px rgba(0, 0, 0, 0.35);
+}
+.veo-pick-label .veo-pick-sel { color: #c7d2fe; word-break: break-all; }
+.veo-pick-label .veo-pick-dim { color: #a5b4fc; margin-top: 3px; }
+.veo-pick-hint {
+  position: fixed;
+  top: 12px;
+  left: 50%;
+  transform: translateX(-50%);
+  z-index: ${PICKER_Z};
+  pointer-events: none;
+  background: #4338ca;
+  color: #fff;
+  font: 13px/1 -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, sans-serif;
+  padding: 8px 14px;
+  border-radius: 999px;
+  box-shadow: 0 4px 16px rgba(0, 0, 0, 0.25);
+}
+`;
+var ElementPicker = class {
+  constructor() {
+    this.host = null;
+    this.box = null;
+    this.label = null;
+    this.current = null;
+    this.maxAncestors = DEFAULT_MAX_ANCESTORS;
+    this.onPick = null;
+    this.onCancel = null;
+    this.onMove = (event) => {
+      const target = event.target;
+      if (!(target instanceof Element) || this.isOwn(target)) return;
+      this.current = target;
+      this.draw(target);
+    };
+    this.onClick = (event) => {
+      const target = this.current ?? (event.target instanceof Element ? event.target : null);
+      if (!target || this.isOwn(target)) return;
+      event.preventDefault();
+      event.stopPropagation();
+      event.stopImmediatePropagation();
+      const picked = this.describe(target);
+      const cb = this.onPick;
+      this.stop();
+      cb?.(picked);
+    };
+    this.onKey = (event) => {
+      if (event.key !== "Escape") return;
+      event.preventDefault();
+      event.stopPropagation();
+      const cb = this.onCancel;
+      this.stop();
+      cb?.();
+    };
+    /** Traga mousedown/mouseup durante el picking (evita focus/active de la app). */
+    this.swallow = (event) => {
+      if (this.isOwn(event.target)) return;
+      event.preventDefault();
+      event.stopPropagation();
+    };
+    this.reposition = () => {
+      if (this.current) this.draw(this.current);
+    };
+  }
+  start(options) {
+    this.stop();
+    this.maxAncestors = options.maxAncestors ?? DEFAULT_MAX_ANCESTORS;
+    this.onPick = options.onPick;
+    this.onCancel = options.onCancel ?? null;
+    const host = document.createElement("div");
+    host.setAttribute(PICKER_HOST_ATTR, "");
+    const shadow = host.attachShadow({ mode: "open" });
+    const style = document.createElement("style");
+    style.textContent = PICKER_STYLES;
+    this.box = document.createElement("div");
+    this.box.className = "veo-pick-box";
+    this.box.style.display = "none";
+    this.label = document.createElement("div");
+    this.label.className = "veo-pick-label";
+    this.label.style.display = "none";
+    const hint = document.createElement("div");
+    hint.className = "veo-pick-hint";
+    hint.textContent = options.hint ?? "Seleccion\xE1 un elemento \xB7 Esc para cancelar";
+    shadow.append(style, this.box, this.label, hint);
+    document.body.appendChild(host);
+    this.host = host;
+    document.addEventListener("mousemove", this.onMove, true);
+    document.addEventListener("click", this.onClick, true);
+    document.addEventListener("mousedown", this.swallow, true);
+    document.addEventListener("mouseup", this.swallow, true);
+    document.addEventListener("keydown", this.onKey, true);
+    window.addEventListener("scroll", this.reposition, true);
+    window.addEventListener("resize", this.reposition);
+  }
+  stop() {
+    document.removeEventListener("mousemove", this.onMove, true);
+    document.removeEventListener("click", this.onClick, true);
+    document.removeEventListener("mousedown", this.swallow, true);
+    document.removeEventListener("mouseup", this.swallow, true);
+    document.removeEventListener("keydown", this.onKey, true);
+    window.removeEventListener("scroll", this.reposition, true);
+    window.removeEventListener("resize", this.reposition);
+    if (this.host?.parentNode) this.host.parentNode.removeChild(this.host);
+    this.host = null;
+    this.box = null;
+    this.label = null;
+    this.current = null;
+    this.onPick = null;
+    this.onCancel = null;
+  }
+  /** ¿Es un nodo de nuestro propio overlay? (no debe ser seleccionable). */
+  isOwn(target) {
+    return target instanceof Node && this.host !== null && this.host.contains(target);
+  }
+  /** Dibuja el recuadro de resalte y la etiqueta sobre el elemento dado. */
+  draw(element) {
+    if (!this.box || !this.label) return;
+    const rect = element.getBoundingClientRect();
+    this.box.style.display = "block";
+    this.box.style.top = `${rect.top}px`;
+    this.box.style.left = `${rect.left}px`;
+    this.box.style.width = `${rect.width}px`;
+    this.box.style.height = `${rect.height}px`;
+    const shortSel = buildSelectorPath(element, 0);
+    this.label.textContent = "";
+    const sel = document.createElement("div");
+    sel.className = "veo-pick-sel";
+    sel.textContent = shortSel;
+    const dim = document.createElement("div");
+    dim.className = "veo-pick-dim";
+    dim.textContent = `${Math.round(rect.width)} \xD7 ${Math.round(rect.height)}`;
+    this.label.append(sel, dim);
+    this.label.style.display = "block";
+    const LABEL_H = 48;
+    const placeAbove = rect.bottom + 8 + LABEL_H > window.innerHeight;
+    this.label.style.top = placeAbove ? `${Math.max(8, rect.top - LABEL_H - 8)}px` : `${rect.bottom + 8}px`;
+    this.label.style.left = `${Math.max(8, rect.left)}px`;
+  }
+  describe(element) {
+    const rect = element.getBoundingClientRect();
+    return {
+      selector: buildSelectorPath(element, this.maxAncestors),
+      shortSelector: buildSelectorPath(element, 0),
+      tag: element.tagName.toLowerCase(),
+      id: element.id || null,
+      classes: filterHumanClasses(element),
+      text: (element.textContent ?? "").trim().slice(0, 120),
+      rect: {
+        x: Math.round(rect.left),
+        y: Math.round(rect.top),
+        width: Math.round(rect.width),
+        height: Math.round(rect.height)
+      }
+    };
+  }
+};
+var activePicker = null;
+function startElementPicker(options) {
+  if (!hasDocument()) {
+    return { stop: () => {
+    } };
+  }
+  if (!activePicker) activePicker = new ElementPicker();
+  activePicker.start(options);
+  return { stop: () => activePicker?.stop() };
+}
+function stopElementPicker() {
+  activePicker?.stop();
+}
+
+// src/plugins/builder/builder-mode.ts
+function initBuilderMode() {
+  if (!hasWindow() || !hasDocument()) return null;
+  let params;
+  try {
+    params = new URLSearchParams(window.location.search);
+  } catch {
+    return null;
+  }
+  const token = params.get(BUILDER_TOKEN_PARAM);
+  if (!token) return null;
+  const dashboardOrigin = resolveDashboardOrigin(params);
+  if (!dashboardOrigin) return null;
+  const target = resolveTarget();
+  if (!target) return null;
+  let picker = null;
+  const post = (event) => {
+    target.postMessage({ source: VEO_BUILDER_SOURCE, token, ...event }, dashboardOrigin);
+  };
+  const handleCommand = (cmd) => {
+    switch (cmd.type) {
+      case "start-picker":
+        picker?.stop();
+        picker = startElementPicker({
+          onPick: (payload) => {
+            picker = null;
+            post({ type: "picked", payload });
+          },
+          onCancel: () => {
+            picker = null;
+            post({ type: "pick-cancelled" });
+          },
+          ...cmd.maxAncestors !== void 0 ? { maxAncestors: cmd.maxAncestors } : {},
+          ...cmd.hint !== void 0 ? { hint: cmd.hint } : {}
+        });
+        break;
+      case "stop-picker":
+        picker?.stop();
+        picker = null;
+        break;
+      case "preview":
+        if (cmd.guide) void previewGuide(cmd.guide).ready;
+        break;
+      case "close-preview":
+        closeGuidePreview();
+        break;
+      case "teardown":
+        teardown();
+        break;
+    }
+  };
+  const onMessage = (event) => {
+    if (event.origin !== dashboardOrigin) return;
+    const data = event.data;
+    if (!data || data.source !== VEO_BUILDER_SOURCE || data.token !== token) return;
+    handleCommand(data);
+  };
+  const onPageHide = () => post({ type: "closed" });
+  const teardown = () => {
+    window.removeEventListener("message", onMessage);
+    window.removeEventListener("pagehide", onPageHide);
+    picker?.stop();
+    picker = null;
+    closeGuidePreview();
+    post({ type: "closed" });
+  };
+  const activate = () => {
+    window.addEventListener("message", onMessage);
+    window.addEventListener("pagehide", onPageHide);
+    post({ type: "ready" });
+  };
+  const cfg = window.__veoBuilder;
+  if (cfg?.apiKey && cfg?.apiUrl) {
+    void verifyBuilderToken(cfg.apiUrl, cfg.apiKey, token).then((ok) => {
+      if (ok) activate();
+      else if (window.console) console.warn("[veo] token de builder inv\xE1lido \u2014 modo no activado");
+    });
+  } else {
+    activate();
+  }
+  return { teardown };
+}
+async function verifyBuilderToken(apiUrl, apiKey, token) {
+  try {
+    const url = `${apiUrl.replace(/\/+$/, "")}/v1/builder/verify`;
+    const res = await fetch(url, {
+      method: "POST",
+      headers: { "Content-Type": "application/json", "X-Api-Key": apiKey },
+      body: JSON.stringify({ token })
+    });
+    if (!res.ok) return true;
+    const data = await res.json().catch(() => null);
+    return data?.valid !== false;
+  } catch {
+    return true;
+  }
+}
+function resolveTarget() {
+  if (window.opener && window.opener !== window) return window.opener;
+  if (window.parent && window.parent !== window) return window.parent;
+  return null;
+}
+function resolveDashboardOrigin(params) {
+  const explicit = params.get(BUILDER_ORIGIN_PARAM);
+  if (explicit) {
+    try {
+      return new URL(explicit).origin;
+    } catch {
+      return null;
+    }
+  }
+  if (document.referrer) {
+    try {
+      return new URL(document.referrer).origin;
+    } catch {
+      return null;
+    }
+  }
+  return null;
+}
+
+// src/plugins/builder/builder-session.ts
+var DEFAULT_FEATURES = "popup,width=1280,height=860";
+var POPUP_POLL_MS = 600;
+function createBuilderSession(options) {
+  if (!hasWindow()) return noopSession();
+  const dashboardOrigin = options.dashboardOrigin ?? window.location.origin;
+  const appOrigin = safeOrigin(options.appUrl);
+  const url = buildAppUrl(options.appUrl, options.token, dashboardOrigin);
+  const frame = options.frame ?? null;
+  const useFrame = frame !== null;
+  let popup = null;
+  if (useFrame) {
+    frame.src = url;
+  } else {
+    popup = window.open(
+      url,
+      options.windowName ?? "veo-builder",
+      options.windowFeatures ?? DEFAULT_FEATURES
+    );
+  }
+  const targetWindow = () => useFrame ? frame?.contentWindow ?? null : popup;
+  const post = (command) => {
+    const w = targetWindow();
+    if (!w) return;
+    if (!useFrame && popup?.closed) return;
+    w.postMessage(
+      { source: VEO_BUILDER_SOURCE, token: options.token, ...command },
+      appOrigin ?? "*"
+    );
+  };
+  let pollTimer;
+  const cleanup = () => {
+    window.removeEventListener("message", onMessage);
+    if (pollTimer !== void 0) {
+      clearInterval(pollTimer);
+      pollTimer = void 0;
+    }
+  };
+  const onMessage = (event) => {
+    if (appOrigin && event.origin !== appOrigin) return;
+    const data = event.data;
+    if (!data || data.source !== VEO_BUILDER_SOURCE || data.token !== options.token) return;
+    switch (data.type) {
+      case "ready":
+        options.onReady?.();
+        break;
+      case "picked":
+        if (data.payload) options.onPicked?.(data.payload);
+        break;
+      case "pick-cancelled":
+        options.onCancelled?.();
+        break;
+      case "closed":
+        cleanup();
+        options.onClosed?.();
+        break;
+    }
+  };
+  window.addEventListener("message", onMessage);
+  if (!useFrame) {
+    pollTimer = setInterval(() => {
+      if (popup?.closed) {
+        cleanup();
+        options.onClosed?.();
+      }
+    }, POPUP_POLL_MS);
+  }
+  return {
+    startPicker: (o) => post({
+      type: "start-picker",
+      ...o?.maxAncestors !== void 0 ? { maxAncestors: o.maxAncestors } : {},
+      ...o?.hint !== void 0 ? { hint: o.hint } : {}
+    }),
+    stopPicker: () => post({ type: "stop-picker" }),
+    preview: (guide) => post({ type: "preview", guide }),
+    closePreview: () => post({ type: "close-preview" }),
+    close: () => {
+      post({ type: "teardown" });
+      if (useFrame) {
+        if (frame) frame.src = "about:blank";
+      } else if (popup && !popup.closed) {
+        popup.close();
+      }
+      cleanup();
+    }
+  };
+}
+function buildAppUrl(appUrl, token, dashboardOrigin) {
+  try {
+    const u = new URL(appUrl, window.location.href);
+    u.searchParams.set(BUILDER_TOKEN_PARAM, token);
+    u.searchParams.set(BUILDER_ORIGIN_PARAM, dashboardOrigin);
+    return u.toString();
+  } catch {
+    return appUrl;
+  }
+}
+function safeOrigin(url) {
+  try {
+    return new URL(url, window.location.href).origin;
+  } catch {
+    return null;
+  }
+}
+function noopSession() {
+  return {
+    startPicker: () => {
+    },
+    stopPicker: () => {
+    },
+    preview: () => {
+    },
+    closePreview: () => {
+    },
+    close: () => {
+    }
+  };
+}
+
+// src/builder.ts
+initBuilderMode();
+
+exports.closeGuidePreview = closeGuidePreview;
+exports.createBuilderSession = createBuilderSession;
+exports.initBuilderMode = initBuilderMode;
+exports.previewGuide = previewGuide;
+exports.startElementPicker = startElementPicker;
+exports.stopElementPicker = stopElementPicker;
+//# sourceMappingURL=builder.cjs.map
+//# sourceMappingURL=builder.cjs.map