@bitam/ebavel-apps 0.0.0-stage → 0.1.0

package/dist/index.js

@@ -0,0 +1,729 @@
+import {
+  CDN_ORIGINS
+} from "./chunk-FFVQA4KG.js";
+
+// src/sdk/errors.ts
+var ERROR_CODES = ["NOT_CONNECTED", "DECLINED", "TOOL_ERROR", "UNSUPPORTED", "TIMEOUT", "ABORTED", "INVALID_ARGS"];
+var isErrorCode = (v) => typeof v === "string" && ERROR_CODES.includes(v);
+var MAX_MESSAGE = 500;
+var isRecord = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+var clip = (s, max = MAX_MESSAGE) => s.length > max ? `${s.slice(0, max)}\u2026` : s;
+var EbavelAppError = class extends Error {
+  code;
+  /** Cuerpo del error de la tool (p. ej. `{ success: false, errors: [...] }`), si lo hubo. */
+  details;
+  constructor(code, message, details) {
+    super(clip(message));
+    this.name = "EbavelAppError";
+    this.code = code;
+    if (details !== void 0) this.details = details;
+  }
+};
+function toAppError(e, fallback = "TOOL_ERROR") {
+  if (e instanceof EbavelAppError) return e;
+  if (e instanceof Error) return new EbavelAppError(fallback, e.message);
+  if (isRecord(e) && typeof e.message === "string") return new EbavelAppError(fallback, e.message);
+  return new EbavelAppError(fallback, typeof e === "string" ? e : "Error desconocido");
+}
+
+// src/sdk/result.ts
+function textOf(res) {
+  const content = Array.isArray(res.content) ? res.content : [];
+  const item = content.find((x) => isRecord(x) && x.type === "text" && typeof x.text === "string");
+  return item?.text;
+}
+function errorMessageOf(body, fallback) {
+  if (isRecord(body)) {
+    const first = Array.isArray(body.errors) ? body.errors[0] : void 0;
+    if (isRecord(first) && typeof first.message === "string") return typeof first.code === "string" ? `${first.code}: ${first.message}` : first.message;
+    if (isRecord(body.error) && typeof body.error.message === "string") return body.error.message;
+    if (typeof body.error === "string") return body.error;
+    if (typeof body.message === "string") return body.message;
+  }
+  return fallback;
+}
+function unwrapToolResult(res) {
+  if (!isRecord(res)) throw new EbavelAppError("TOOL_ERROR", "La tool devolvi\xF3 una respuesta que no es un objeto.");
+  let payload = res.payload ?? res.structuredContent;
+  const text = textOf(res);
+  if ((payload === void 0 || payload === null) && text !== void 0) {
+    try {
+      payload = JSON.parse(text);
+    } catch {
+      if (res.isError === true) throw new EbavelAppError("TOOL_ERROR", clip(text));
+      throw new EbavelAppError("TOOL_ERROR", "La tool devolvi\xF3 un texto que no es JSON.");
+    }
+  }
+  if (res.isError === true) throw new EbavelAppError("TOOL_ERROR", errorMessageOf(payload, text ?? "La tool devolvi\xF3 un error."), payload);
+  if (payload === void 0 || payload === null) throw new EbavelAppError("TOOL_ERROR", "La tool no devolvi\xF3 un resultado.");
+  return payload;
+}
+function assertSuccessBody(payload) {
+  if (!isRecord(payload)) throw new EbavelAppError("TOOL_ERROR", "La respuesta de la tool no es un objeto.");
+  if (payload.success === false || payload.error !== void 0) throw new EbavelAppError("TOOL_ERROR", errorMessageOf(payload, "La tool devolvi\xF3 un error."), payload);
+  return payload;
+}
+
+// src/sdk/url.ts
+var LOCAL_HOSTS = /* @__PURE__ */ new Set(["localhost", "127.0.0.1"]);
+var isDevBuild = () => typeof __EBAVEL_DEV__ === "boolean" && __EBAVEL_DEV__;
+function safeUrl(v) {
+  if (typeof v !== "string" || v.length > 4096) return null;
+  try {
+    const u = new URL(v);
+    return u.protocol === "https:" || isDevBuild() && u.protocol === "http:" && LOCAL_HOSTS.has(u.hostname) ? u.toString() : null;
+  } catch {
+    return null;
+  }
+}
+
+// src/sdk/claude.ts
+var SIGNATURE_TOOLS = ["query", "describe_form"];
+var REJECTION_CODES = {
+  bad_request: "TOOL_ERROR",
+  server_not_connected: "NOT_CONNECTED",
+  needs_reauth: "NOT_CONNECTED",
+  selection_required: "NOT_CONNECTED",
+  not_in_manifest: "DECLINED",
+  approval_required: "DECLINED",
+  consent_required: "DECLINED",
+  blocked_by_policy: "DECLINED"
+};
+function mapClaudeRejection(e) {
+  if (e instanceof EbavelAppError) return e;
+  const code = isRecord(e) && typeof e.code === "string" ? e.code : void 0;
+  const message = isRecord(e) && typeof e.message === "string" ? e.message : e instanceof Error ? e.message : typeof e === "string" ? e : "Error de Claude";
+  const mapped = (code !== void 0 ? REJECTION_CODES[code] : void 0) ?? "TOOL_ERROR";
+  const hint = mapped === "NOT_CONNECTED" ? " Conecta (o vuelve a autorizar) el conector eBavel en claude.ai." : mapped === "DECLINED" ? " Acepta el permiso de conectores que muestra claude.ai al abrir el artifact." : "";
+  return new EbavelAppError(mapped, `${code ? `[${code}] ` : ""}${message}${hint}`);
+}
+var isMcp = (v) => isRecord(v) && typeof v.callTool === "function" && typeof v.listTools === "function";
+function candidatesOf(listing) {
+  const servers = isRecord(listing) && Array.isArray(listing.servers) ? listing.servers : [];
+  const all = [];
+  const matching = [];
+  for (const s of servers) {
+    if (!isRecord(s) || typeof s.server !== "string") continue;
+    all.push(s.server);
+    const names = new Set((Array.isArray(s.tools) ? s.tools : []).map((t) => isRecord(t) ? t.name : t));
+    if (SIGNATURE_TOOLS.every((t) => names.has(t))) matching.push(s.server);
+  }
+  return { all, matching };
+}
+function createClaudeConductor(opts) {
+  let mcpPromise;
+  let discovered;
+  const getMcp = () => {
+    mcpPromise ??= (async () => {
+      let mcp;
+      try {
+        mcp = await opts.claude.use("mcp");
+      } catch (e) {
+        mcpPromise = void 0;
+        throw mapClaudeRejection(e);
+      }
+      if (!isMcp(mcp)) {
+        mcpPromise = void 0;
+        throw new EbavelAppError("NOT_CONNECTED", 'Claude no expone el acceso a conectores MCP (`window.claude.use("mcp")`). Declara el conector eBavel al crear el artifact.');
+      }
+      return mcp;
+    })();
+    return mcpPromise;
+  };
+  async function resolveServer(mcp) {
+    const fixed = opts.getServer();
+    if (fixed !== void 0) return fixed;
+    if (discovered !== void 0) return discovered;
+    let listing;
+    try {
+      listing = await mcp.listTools();
+    } catch (e) {
+      throw mapClaudeRejection(e);
+    }
+    const { all, matching } = candidatesOf(listing);
+    const only = matching[0];
+    if (matching.length === 1 && only !== void 0) {
+      discovered = only;
+      return only;
+    }
+    const list = (names) => names.length > 0 ? names.map((n) => `\xAB${n}\xBB`).join(", ") : "ninguno";
+    throw new EbavelAppError(
+      "NOT_CONNECTED",
+      matching.length === 0 ? `No hay ning\xFAn conector con las tools ${SIGNATURE_TOOLS.join(" y ")}. Conectores disponibles: ${list(all)}. Conecta eBavel en claude.ai o usa ebavel.configure({ server }).` : `Hay m\xE1s de un conector eBavel candidato: ${list(matching)}. Elige uno con ebavel.configure({ server: '\u2026' }).`
+    );
+  }
+  async function call(tool, args) {
+    const mcp = await getMcp();
+    const server = await resolveServer(mcp);
+    let res;
+    try {
+      res = await mcp.callTool(server, tool, args);
+    } catch (e) {
+      throw mapClaudeRejection(e);
+    }
+    return unwrapToolResult(res);
+  }
+  return {
+    host: "claude",
+    canExport: true,
+    query: (args) => call("query", args),
+    async export(input) {
+      const { html, title } = input.source(input.title);
+      const body = assertSuccessBody(await call("export_dashboard", { html, title }));
+      const importUrl = safeUrl(body.importUrl);
+      if (importUrl === null) throw new EbavelAppError("TOOL_ERROR", "La respuesta de export_dashboard no trae un enlace https v\xE1lido.");
+      const expiresAt = typeof body.expiresAt === "string" ? clip(body.expiresAt, 64) : void 0;
+      return { importUrl, ...expiresAt !== void 0 ? { expiresAt } : {}, opened: opts.open(importUrl) };
+    },
+    openLink(url) {
+      const safe = safeUrl(url);
+      if (safe === null) return Promise.reject(new EbavelAppError("INVALID_ARGS", "Solo se pueden abrir enlaces https."));
+      return Promise.resolve({ opened: opts.open(safe), url: safe });
+    }
+  };
+}
+
+// src/sdk/limiter.ts
+var MAX_IN_FLIGHT = 4;
+var aborted = () => new EbavelAppError("ABORTED", "La operaci\xF3n se cancel\xF3.");
+var Limiter = class {
+  constructor(max = MAX_IN_FLIGHT) {
+    this.max = max;
+  }
+  max;
+  active = 0;
+  waiting = [];
+  pump() {
+    while (this.active < this.max && this.waiting.length > 0) this.waiting.shift().start();
+  }
+  acquire(signal) {
+    if (signal?.aborted) return Promise.reject(aborted());
+    return new Promise((resolve, reject) => {
+      if (this.active < this.max) {
+        this.active++;
+        return resolve();
+      }
+      const entry = {
+        start: () => {
+          signal?.removeEventListener("abort", entry.cancel);
+          this.active++;
+          resolve();
+        },
+        cancel: () => {
+          const i = this.waiting.indexOf(entry);
+          if (i >= 0) this.waiting.splice(i, 1);
+          reject(aborted());
+        }
+      };
+      signal?.addEventListener("abort", entry.cancel, { once: true });
+      this.waiting.push(entry);
+    });
+  }
+  /**
+   * Ejecuta `fn` cuando haya un lugar libre. El plazo cuenta desde que arranca (no desde que espera en la cola).
+   * Un lugar se libera cuando `fn` termina, o al vencer el plazo; al cancelar, cuando `fn` termina (la llamada
+   * sigue en el anfitrión y cuenta contra su propio límite).
+   */
+  async run(fn, opts) {
+    await this.acquire(opts.signal);
+    let released = false;
+    const release = () => {
+      if (released) return;
+      released = true;
+      this.active--;
+      this.pump();
+    };
+    let work;
+    try {
+      work = fn();
+    } catch (e) {
+      release();
+      throw e;
+    }
+    work.then(release, release);
+    return new Promise((resolve, reject) => {
+      const { signal } = opts;
+      const onAbort = () => {
+        cleanup();
+        reject(aborted());
+      };
+      const timer = setTimeout(() => {
+        cleanup();
+        release();
+        reject(new EbavelAppError("TIMEOUT", `El anfitri\xF3n no respondi\xF3 en ${Math.round(opts.timeoutMs / 1e3)} s.`));
+      }, opts.timeoutMs);
+      const cleanup = () => {
+        clearTimeout(timer);
+        signal?.removeEventListener("abort", onAbort);
+      };
+      signal?.addEventListener("abort", onAbort, { once: true });
+      work.then(
+        (v) => {
+          cleanup();
+          resolve(v);
+        },
+        (e) => {
+          cleanup();
+          reject(e instanceof Error ? e : new Error(String(e)));
+        }
+      );
+    });
+  }
+};
+
+// src/sdk/hostvars.ts
+var VAR_RE = /^--[a-z0-9-]+$/;
+var VALUE_RE = /^[^;{}<>\\]{1,200}$/;
+var RESOURCE_RE = /url\s*\(|image-set\s*\(|@import/i;
+var MAX_VARS = 200;
+var LANG_RE = /^[A-Za-z]{2,3}(?:-[A-Za-z0-9]{2,8}){0,3}$/;
+var asTheme = (v) => v === "light" || v === "dark" ? v : void 0;
+var asLang = (v) => typeof v === "string" && LANG_RE.test(v) ? v : void 0;
+function sanitizeVars(vars) {
+  const out = {};
+  if (!isRecord(vars)) return out;
+  let n = 0;
+  for (const [name, value] of Object.entries(vars)) {
+    if (n >= MAX_VARS) break;
+    if (typeof value === "string" && VAR_RE.test(name) && VALUE_RE.test(value) && !RESOURCE_RE.test(value)) {
+      out[name] = value;
+      n++;
+    }
+  }
+  return out;
+}
+
+// src/sdk/protocol.ts
+var PROTOCOL_VERSION = 1;
+var MAX_REQUEST_BYTES = 128 * 1024;
+var MAX_ID_LENGTH = 64;
+var envelope = (msg) => ({ ebavel: PROTOCOL_VERSION, ...msg });
+var validId = (v) => typeof v === "string" && v.length > 0 && v.length <= MAX_ID_LENGTH;
+function parseRunnerMessage(data) {
+  if (!isRecord(data) || data.ebavel !== PROTOCOL_VERSION) return null;
+  switch (data.type) {
+    case "ready": {
+      const theme = asTheme(data.theme);
+      const lang = asLang(data.lang);
+      if (!validId(data.id) || !theme || typeof data.canExport !== "boolean") return null;
+      return { type: "ready", id: data.id, theme, lang: lang ?? "es", vars: sanitizeVars(data.vars), canExport: data.canExport };
+    }
+    case "result":
+      return validId(data.id) && "value" in data ? { type: "result", id: data.id, value: data.value } : null;
+    case "error": {
+      if (!validId(data.id) || !isErrorCode(data.code) || typeof data.message !== "string") return null;
+      return { type: "error", id: data.id, code: data.code, message: clip(data.message), ..."details" in data ? { details: data.details } : {} };
+    }
+    case "theme": {
+      const theme = asTheme(data.theme);
+      return theme ? { type: "theme", theme, lang: asLang(data.lang) ?? "es", vars: sanitizeVars(data.vars) } : null;
+    }
+    default:
+      return null;
+  }
+}
+
+// src/sdk/mcp-apps.ts
+var HELLO_SCHEDULE = [0, 200, 500, 1e3, 2e3, 3500];
+var MAX_REPORTED_HEIGHT = 4e3;
+function idFactory() {
+  const salt = Math.random().toString(36).slice(2, 8);
+  let n = 0;
+  return () => `c${++n}-${salt}`;
+}
+function startSizeReporter(win, send) {
+  const root = win.document.documentElement;
+  let last = -1;
+  let scheduled = false;
+  const report = () => {
+    scheduled = false;
+    const h = Math.min(Math.ceil(root.getBoundingClientRect().height), MAX_REPORTED_HEIGHT);
+    if (h > 0 && h !== last) {
+      last = h;
+      send({ type: "size", height: h });
+    }
+  };
+  const schedule = () => {
+    if (scheduled) return;
+    scheduled = true;
+    if (typeof win.requestAnimationFrame === "function") win.requestAnimationFrame(report);
+    else win.setTimeout(report, 16);
+  };
+  const RO = win.ResizeObserver;
+  if (typeof RO === "function") {
+    const ro = new RO(schedule);
+    ro.observe(root);
+    if (win.document.body) ro.observe(win.document.body);
+    else win.addEventListener("DOMContentLoaded", () => ro.observe(win.document.body), { once: true });
+  }
+  win.addEventListener("load", schedule, { once: true });
+  schedule();
+}
+function connectMcpApps(win, opts) {
+  const parent = win.parent;
+  const nextId = idFactory();
+  const pending = /* @__PURE__ */ new Map();
+  const helloIds = /* @__PURE__ */ new Set();
+  const timers = [];
+  let handshaken = false;
+  let firstDone = false;
+  let resolveFirst;
+  let resolveSettled;
+  const first = new Promise((r) => resolveFirst = r);
+  const settled = new Promise((r) => resolveSettled = r);
+  const send = (msg) => {
+    parent.postMessage(envelope(msg), "*");
+  };
+  const request = (build) => new Promise((resolve, reject) => {
+    const msg = build(nextId());
+    pending.set(msg.id, { resolve, reject });
+    try {
+      send(msg);
+    } catch (e) {
+      pending.delete(msg.id);
+      reject(toAppError(e));
+    }
+  });
+  const conductorFor = (canExport) => ({
+    host: "mcp-apps",
+    canExport,
+    async query(args) {
+      const m = await request((id) => ({ type: "query", id, args }));
+      if (m.type !== "result") throw new EbavelAppError("TOOL_ERROR", "Respuesta inesperada del runner.");
+      return m.value;
+    },
+    async export() {
+      const m = await request((id) => ({ type: "export", id }));
+      const v = m.type === "result" && typeof m.value === "object" && m.value !== null ? m.value : void 0;
+      const importUrl = v ? safeUrl(v.importUrl) : null;
+      if (!v || importUrl === null) throw new EbavelAppError("TOOL_ERROR", "Respuesta de exportaci\xF3n inv\xE1lida.");
+      return { importUrl, ...typeof v.expiresAt === "string" ? { expiresAt: v.expiresAt } : {}, opened: v.opened === true };
+    },
+    async openLink(url) {
+      const safe = safeUrl(url);
+      if (safe === null) throw new EbavelAppError("INVALID_ARGS", "Solo se pueden abrir enlaces https.");
+      const m = await request((id) => ({ type: "openLink", id, url: safe }));
+      const v = m.type === "result" && typeof m.value === "object" && m.value !== null ? m.value : void 0;
+      return { opened: v?.opened === true, url: safe };
+    }
+  });
+  const stop = () => {
+    for (const t of timers) win.clearTimeout(t);
+    timers.length = 0;
+    if (!handshaken) win.removeEventListener("message", onMessage);
+    resolveSettled();
+  };
+  function onMessage(ev) {
+    if (ev.source !== win.parent) return;
+    const msg = parseRunnerMessage(ev.data);
+    if (!msg) return;
+    if (msg.type === "theme") {
+      opts.onTheme({ theme: msg.theme, lang: msg.lang, vars: msg.vars });
+      return;
+    }
+    if (msg.type === "ready") {
+      if (!helloIds.has(msg.id) || handshaken) return;
+      handshaken = true;
+      startSizeReporter(win, send);
+      const hs = { conductor: conductorFor(msg.canExport), theme: msg.theme, lang: msg.lang, vars: msg.vars };
+      for (const t of timers) win.clearTimeout(t);
+      timers.length = 0;
+      if (firstDone) opts.onLate(hs);
+      else {
+        firstDone = true;
+        resolveFirst(hs);
+      }
+      resolveSettled();
+      return;
+    }
+    const entry = pending.get(msg.id);
+    if (!entry) return;
+    pending.delete(msg.id);
+    if (msg.type === "error") entry.reject(new EbavelAppError(msg.code, msg.message, msg.details));
+    else entry.resolve(msg);
+  }
+  win.addEventListener("message", onMessage);
+  for (const at of HELLO_SCHEDULE) {
+    if (at >= opts.retryMs) break;
+    const fire = () => {
+      if (handshaken) return;
+      const id = nextId();
+      helloIds.add(id);
+      try {
+        send({ type: "hello", id });
+      } catch {
+      }
+    };
+    if (at === 0) fire();
+    else timers.push(win.setTimeout(fire, at));
+  }
+  timers.push(
+    win.setTimeout(() => {
+      if (!firstDone) {
+        firstDone = true;
+        resolveFirst(null);
+      }
+    }, Math.min(opts.helloTimeoutMs, opts.retryMs))
+  );
+  timers.push(win.setTimeout(stop, opts.retryMs));
+  return { first, settled };
+}
+
+// src/sdk/source.ts
+var SOURCE_TEMPLATE_ID = "ebavel-source";
+var MAX_HTML_BYTES = 512 * 1024;
+var MAX_TITLE = 120;
+var CRED_KEY = /["'`]\s*cred\s*["'`]|(?:^|[^\w$.-])cred\s*:/;
+var hasClaudeCredential = (s) => s.includes("__FRAME_") || CRED_KEY.test(s);
+var MISSING_TEMPLATE = 'Para exportar desde Claude, envuelve tu dashboard en <template id="ebavel-source"> (ver SDK.md). El SDK nunca env\xEDa el documento completo: trae credenciales de Claude.';
+var utf8Length = (s) => new TextEncoder().encode(s).length;
+var normalizeTitle = (s) => clip(s.replace(/\s+/g, " ").trim() || "Dashboard", MAX_TITLE);
+function createSource(win) {
+  const doc = win.document;
+  let snapshot;
+  const take = () => {
+    const all = Array.from(doc.querySelectorAll(`[id="${SOURCE_TEMPLATE_ID}"]`));
+    if (all.length > 1) return { kind: "duplicate" };
+    const el = all[0];
+    if (el !== void 0 && el.tagName === "TEMPLATE" && (el.parentElement === doc.head || el.parentElement === doc.body)) return { kind: "html", html: el.innerHTML };
+    return { kind: "none" };
+  };
+  const titleOf = () => normalizeTitle(doc.title || doc.querySelector("h1")?.textContent || "");
+  return {
+    capture() {
+      snapshot ??= take();
+    },
+    get(titleOverride) {
+      snapshot ??= take();
+      if (snapshot.kind === "duplicate") throw new EbavelAppError("INVALID_ARGS", `Hay m\xE1s de un elemento con id="${SOURCE_TEMPLATE_ID}": solo puede haber un <template>.`);
+      if (snapshot.kind === "none") throw new EbavelAppError("INVALID_ARGS", MISSING_TEMPLATE);
+      const title = titleOverride === void 0 ? titleOf() : normalizeTitle(titleOverride);
+      const titleEl = doc.createElement("title");
+      titleEl.textContent = title;
+      const html = `<!doctype html>
+<html lang="${asLang(doc.documentElement.lang) ?? "es"}"><head><meta charset="utf-8">${titleEl.outerHTML}</head><body>${snapshot.html}</body></html>`;
+      if (hasClaudeCredential(html)) {
+        throw new EbavelAppError("INVALID_ARGS", "El HTML a exportar contiene `__FRAME_` o una llave `cred` (la credencial del frame de Claude, o texto que se le parece); no se envi\xF3 ni se modific\xF3 nada.");
+      }
+      if (utf8Length(html) > MAX_HTML_BYTES) throw new EbavelAppError("INVALID_ARGS", `El HTML supera el m\xE1ximo de ${MAX_HTML_BYTES / 1024} KB.`);
+      return { html, title };
+    }
+  };
+}
+
+// src/sdk/theme.ts
+function createThemeApplier(doc) {
+  let applied = /* @__PURE__ */ new Set();
+  return {
+    apply(theme, vars) {
+      const root = doc.documentElement;
+      root.setAttribute("data-theme", theme);
+      root.style.colorScheme = theme;
+      const now = /* @__PURE__ */ new Set();
+      for (const [name, value] of Object.entries(vars)) {
+        root.style.setProperty(name, value);
+        now.add(name);
+      }
+      for (const name of applied) if (!now.has(name)) root.style.removeProperty(name);
+      applied = now;
+    }
+  };
+}
+function systemTheme(win) {
+  try {
+    return typeof win.matchMedia === "function" && win.matchMedia("(prefers-color-scheme: dark)").matches ? "dark" : "light";
+  } catch {
+    return "light";
+  }
+}
+
+// src/sdk/version.ts
+var VERSION = "0.1.0";
+
+// src/sdk/core.ts
+var SDK_MARK = /* @__PURE__ */ Symbol.for("@bitam/ebavel-apps");
+var DEFAULT_TIMEOUT_MS = 6e4;
+var HELLO_TIMEOUT_MS = 1500;
+var HELLO_RETRY_MS = 5e3;
+var MAX_ARGS_BYTES = 64 * 1024;
+var claudeOf = (win) => {
+  const c = win.claude;
+  return isRecord(c) && typeof c.use === "function" ? c : void 0;
+};
+var NO_HOST = "No hay anfitri\xF3n: abre el dashboard como artifact de Claude (con el conector eBavel) o dentro del runner MCP Apps.";
+function openWindow(win, url) {
+  try {
+    if (win?.navigator?.userActivation?.isActive !== true) return false;
+    const w = win.open(url, "_blank");
+    if (!w) return false;
+    try {
+      w.opener = null;
+    } catch {
+    }
+    return true;
+  } catch {
+    return false;
+  }
+}
+function checkArgs(args) {
+  if (!isRecord(args)) throw new EbavelAppError("INVALID_ARGS", "ebavel.query espera un objeto: { queries: { alias: { entity, \u2026 } } }.");
+  let json;
+  try {
+    json = JSON.stringify(args);
+  } catch {
+    throw new EbavelAppError("INVALID_ARGS", "Los argumentos de ebavel.query no se pueden serializar a JSON.");
+  }
+  if (json.length > MAX_ARGS_BYTES) throw new EbavelAppError("INVALID_ARGS", `Los argumentos de ebavel.query superan ${MAX_ARGS_BYTES / 1024} KB.`);
+}
+function createSdk(win, options = {}) {
+  const config = { timeoutMs: DEFAULT_TIMEOUT_MS };
+  const limiter = new Limiter();
+  const listeners = /* @__PURE__ */ new Set();
+  let theme = win ? systemTheme(win) : "light";
+  const applier = win ? createThemeApplier(win.document) : void 0;
+  const source = win ? createSource(win) : void 0;
+  let conductor = null;
+  let session;
+  let claudeSetUp = false;
+  if (win && source) {
+    const doc = win.document;
+    if (doc.readyState === "loading") doc.addEventListener("DOMContentLoaded", () => source.capture(), { once: true });
+    else source.capture();
+  }
+  const setTheme = (next, vars) => {
+    applier?.apply(next, vars);
+    if (next === theme) return;
+    theme = next;
+    for (const fn of [...listeners]) {
+      try {
+        fn(next);
+      } catch {
+      }
+    }
+  };
+  const lang = () => (win?.document.documentElement.lang || win?.navigator?.language || "es").slice(0, 35);
+  function setUpClaude(claude) {
+    if (!win || claudeSetUp) return;
+    claudeSetUp = true;
+    setTheme(systemTheme(win), {});
+    try {
+      win.matchMedia("(prefers-color-scheme: dark)").addEventListener("change", () => setTheme(systemTheme(win), {}));
+    } catch {
+    }
+    conductor = createClaudeConductor({ claude, getServer: () => config.server, open: (url) => openWindow(win, url) });
+  }
+  async function connect() {
+    if (!win) return { host: "none", theme, lang: "es", canExport: false };
+    const claude = claudeOf(win);
+    if (claude) {
+      setUpClaude(claude);
+      return { host: "claude", theme, lang: lang(), canExport: true };
+    }
+    if (win.parent && win.parent !== win) {
+      session = connectMcpApps(win, {
+        helloTimeoutMs: options.helloTimeoutMs ?? HELLO_TIMEOUT_MS,
+        retryMs: options.helloRetryMs ?? HELLO_RETRY_MS,
+        onTheme: (t) => setTheme(t.theme, t.vars),
+        // El runner tardó en escuchar: se adopta cuando contesta (`ready` ya se cumplió con «none»).
+        onLate: (h) => {
+          conductor = h.conductor;
+          setTheme(h.theme, h.vars);
+        }
+      });
+      const hs = await session.first;
+      if (hs) {
+        conductor = hs.conductor;
+        setTheme(hs.theme, hs.vars);
+        return { host: "mcp-apps", theme, lang: hs.lang, canExport: hs.conductor.canExport };
+      }
+    }
+    return { host: "none", theme, lang: lang(), canExport: false };
+  }
+  const ready = connect();
+  const getConductor = async () => {
+    await ready;
+    if (conductor) return conductor;
+    const claude = win ? claudeOf(win) : void 0;
+    if (claude) setUpClaude(claude);
+    if (!conductor && session) await session.settled;
+    if (!conductor) throw new EbavelAppError("NOT_CONNECTED", NO_HOST);
+    return conductor;
+  };
+  const sdk = {
+    version: VERSION,
+    configure(opts) {
+      if (!isRecord(opts)) throw new EbavelAppError("INVALID_ARGS", "ebavel.configure espera un objeto.");
+      if (opts.server !== void 0) {
+        if (typeof opts.server !== "string" || opts.server.trim() === "") throw new EbavelAppError("INVALID_ARGS", "`server` debe ser el nombre del conector (texto no vac\xEDo).");
+        config.server = opts.server;
+      }
+      if (opts.timeoutMs !== void 0) {
+        if (typeof opts.timeoutMs !== "number" || !Number.isFinite(opts.timeoutMs) || opts.timeoutMs < 100 || opts.timeoutMs > 6e5) {
+          throw new EbavelAppError("INVALID_ARGS", "`timeoutMs` debe estar entre 100 y 600000.");
+        }
+        config.timeoutMs = opts.timeoutMs;
+      }
+    },
+    ready,
+    async query(args, opts) {
+      checkArgs(args);
+      const signal = opts?.signal;
+      if (signal?.aborted) throw new EbavelAppError("ABORTED", "La operaci\xF3n se cancel\xF3.");
+      const c = await getConductor();
+      return await limiter.run(() => c.query(args), { ...signal ? { signal } : {}, timeoutMs: config.timeoutMs });
+    },
+    async export(opts) {
+      const rawTitle = opts?.title;
+      if (rawTitle !== void 0 && typeof rawTitle !== "string") throw new EbavelAppError("INVALID_ARGS", "`title` debe ser un texto.");
+      const title = typeof rawTitle === "string" ? normalizeTitle(rawTitle) : void 0;
+      const signal = opts?.signal;
+      if (signal?.aborted) throw new EbavelAppError("ABORTED", "La operaci\xF3n se cancel\xF3.");
+      const c = await getConductor();
+      if (!c.canExport) throw new EbavelAppError("UNSUPPORTED", "Este dashboard ya est\xE1 guardado: no se puede exportar desde aqu\xED.");
+      const input = {
+        source: (t) => {
+          if (!source) throw new EbavelAppError("INVALID_ARGS", "No hay documento del que exportar.");
+          return source.get(t);
+        },
+        title
+      };
+      return limiter.run(() => c.export(input), { ...signal ? { signal } : {}, timeoutMs: config.timeoutMs });
+    },
+    get theme() {
+      return theme;
+    },
+    onThemeChange(listener) {
+      if (typeof listener !== "function") throw new EbavelAppError("INVALID_ARGS", "onThemeChange espera una funci\xF3n.");
+      listeners.add(listener);
+      return () => void listeners.delete(listener);
+    },
+    async openLink(url) {
+      const c = await getConductor();
+      return c.openLink(url);
+    }
+  };
+  Object.defineProperty(sdk, SDK_MARK, { value: true });
+  return sdk;
+}
+function getEbavel(win = typeof window === "undefined" ? void 0 : window, options) {
+  const existing = win?.ebavel;
+  if (isRecord(existing) && existing[SDK_MARK] === true) return existing;
+  const sdk = createSdk(win, options);
+  if (win) Object.defineProperty(win, "ebavel", { value: sdk, configurable: true, writable: true, enumerable: false });
+  return sdk;
+}
+
+// src/sdk/index.ts
+var ebavel = getEbavel();
+export {
+  CDN_ORIGINS,
+  ERROR_CODES,
+  EbavelAppError,
+  PROTOCOL_VERSION,
+  SDK_MARK,
+  VERSION,
+  createSdk,
+  ebavel,
+  getEbavel,
+  isErrorCode
+};