@pixl-app/sdk 0.1.1 → 1.0.0

package/dist/index-nb1y5rx1.js

@@ -0,0 +1,1932 @@
+// src/api-types/templates.ts
+var DEFAULT_AVATAR = "https://static-cdn.jtvnw.net/user-default-pictures-uv/cdd517fe-def4-11e9-948e-784f43822e80-profile_image-300x300.png";
+function templateUser(name, id = "123456789") {
+  return { id, login: name.toLowerCase(), name, avatar: DEFAULT_AVATAR };
+}
+var frostbyte = templateUser("FrostByte", "100000001");
+var nordlicht = templateUser("Nordlicht", "100000002");
+var sophieplays = templateUser("SophiePlays", "100000003");
+var mod = templateUser("JonasNRW", "100000004");
+var hypeTrain = {
+  level: 2,
+  progress: 1200,
+  goal: 3000,
+  total: 4700,
+  expiresAt: "2026-01-01T20:05:00.000Z",
+  startedAt: "2026-01-01T20:00:00.000Z",
+  type: "regular",
+  shared: false,
+  participants: [],
+  topContributions: [
+    { user: frostbyte, type: "bits", total: 2500 },
+    { user: nordlicht, type: "subscription", total: 1500 }
+  ],
+  record: { level: 5, total: 18000 }
+};
+var emote = {
+  id: "60ae958e229664e8667aea38",
+  name: "peepoHey",
+  provider: "7tv",
+  animated: true,
+  zeroWidth: false
+};
+var EVENT_TEMPLATES2 = {
+  "stream.online": {
+    streamId: "40000000000",
+    title: "Gemütlicher Abend mit euch",
+    category: "Minecraft",
+    url: "https://twitch.tv/pixl",
+    thumbnailUrl: null
+  },
+  "stream.offline": { durationSec: 3 * 3600 + 25 * 60 },
+  "twitch.follow": { user: frostbyte },
+  "twitch.sub": {
+    user: frostbyte,
+    tier: "1",
+    months: 7,
+    streak: 4,
+    durationMonths: 1,
+    message: "Sieben Monate schon!"
+  },
+  "twitch.sub_gift": {
+    user: nordlicht,
+    tier: "1",
+    count: 5,
+    community: true,
+    months: 1,
+    recipients: [sophieplays, frostbyte],
+    totalGifted: 42
+  },
+  "twitch.cheer": { user: sophieplays, bits: 500, message: "Cheer500 GG" },
+  "twitch.raid": { user: nordlicht, viewers: 87 },
+  "twitch.channel_point": { user: frostbyte, reward: "Hydrieren", cost: 500, input: null },
+  "twitch.channel_point_resolved": { user: frostbyte, reward: "Hydrieren", status: "fulfilled" },
+  "twitch.power_up": { user: sophieplays, title: "Konfetti", bits: 100, input: null },
+  "twitch.watch_streak": { user: sophieplays, streak: 10, channelPoints: 450 },
+  "twitch.modiversary": { user: mod, months: 24 },
+  "twitch.shoutout_sent": { user: nordlicht, viewers: 87 },
+  "twitch.poll_started": {
+    title: "Welche Welt als Nächstes?",
+    choices: [
+      { title: "Nether", votes: 0 },
+      { title: "End", votes: 0 }
+    ]
+  },
+  "twitch.poll_progress": {
+    title: "Welche Welt als Nächstes?",
+    choices: [
+      { title: "Nether", votes: 12 },
+      { title: "End", votes: 9 }
+    ]
+  },
+  "twitch.poll_ended": {
+    title: "Welche Welt als Nächstes?",
+    status: "completed",
+    choices: [
+      { title: "Nether", votes: 31 },
+      { title: "End", votes: 24 }
+    ]
+  },
+  "twitch.prediction_started": {
+    title: "Schafft er den Boss?",
+    outcomes: [
+      { title: "Ja", points: 0 },
+      { title: "Nein", points: 0 }
+    ]
+  },
+  "twitch.prediction_progress": {
+    title: "Schafft er den Boss?",
+    outcomes: [
+      { title: "Ja", points: 12000 },
+      { title: "Nein", points: 8000 }
+    ]
+  },
+  "twitch.prediction_locked": {
+    title: "Schafft er den Boss?",
+    outcomes: [
+      { title: "Ja", points: 25000 },
+      { title: "Nein", points: 19000 }
+    ]
+  },
+  "twitch.prediction_ended": {
+    title: "Schafft er den Boss?",
+    status: "resolved",
+    winner: "Ja",
+    outcomes: [
+      { title: "Ja", points: 25000 },
+      { title: "Nein", points: 19000 }
+    ]
+  },
+  "twitch.hype_train_started": { ...hypeTrain, level: 1, progress: 400, goal: 2000, total: 400 },
+  "twitch.hype_train_progress": hypeTrain,
+  "twitch.hype_train_ended": { ...hypeTrain, expiresAt: null },
+  "twitch.goal_started": { type: "follower", description: "Follower-Ziel", current: 980, target: 1000 },
+  "twitch.goal_progress": { current: 995, target: 1000 },
+  "twitch.goal_ended": { type: "follower", description: "Follower-Ziel", current: 1003, target: 1000, achieved: true },
+  "twitch.charity_started": { charity: "Ärzte ohne Grenzen", target: { value: 1000, currency: "EUR" } },
+  "twitch.charity_progress": { current: { value: 420, currency: "EUR" }, target: { value: 1000, currency: "EUR" } },
+  "twitch.charity_donated": { user: nordlicht, charity: "Ärzte ohne Grenzen", amount: { value: 25, currency: "EUR" } },
+  "twitch.charity_stopped": {
+    charity: "Ärzte ohne Grenzen",
+    current: { value: 1240, currency: "EUR" },
+    target: { value: 1000, currency: "EUR" }
+  },
+  "twitch.ad_break": { durationSec: 90, automatic: true, startedAt: "2026-01-01T20:30:00.000Z" },
+  "twitch.title_changed": { title: "Endlich das End" },
+  "twitch.category_changed": { category: "Minecraft" },
+  "twitch.ban": {
+    user: nordlicht,
+    moderator: mod,
+    reason: "Spam",
+    permanent: false,
+    endsAt: "2026-01-01T20:10:00.000Z"
+  },
+  "twitch.unban": { user: nordlicht, moderator: mod },
+  "twitch.vip_added": { user: sophieplays },
+  "twitch.vip_removed": { user: sophieplays },
+  "twitch.moderator_added": { user: mod },
+  "twitch.moderator_removed": { user: mod },
+  "twitch.chat_message": {
+    user: frostbyte,
+    messageId: "00000000-0000-0000-0000-000000000001",
+    text: "Hallo zusammen peepoHey",
+    html: 'Hallo zusammen <img class="pixl-emote" src="https://cdn.7tv.app/emote/60ae958e229664e8667aea38/2x.webp" alt="peepoHey" data-provider="7tv" data-emote="60ae958e229664e8667aea38">',
+    color: "#8A5CF5",
+    emotes: { peepoHey: emote },
+    badges: [],
+    paint: null
+  },
+  "twitch.chat_cleared": {},
+  "twitch.chat_user_cleared": { user: nordlicht },
+  "twitch.chat_message_deleted": { user: nordlicht, messageId: "00000000-0000-0000-0000-000000000002" },
+  "twitch.chat_settings_updated": {
+    emoteMode: false,
+    followerMode: true,
+    followerModeDuration: 10,
+    slowMode: true,
+    slowModeWait: 5,
+    subscriberMode: false,
+    uniqueChatMode: false
+  },
+  "twitch.chat_message_held": {
+    user: nordlicht,
+    text: "kauf billige follower",
+    messageId: "00000000-0000-0000-0000-000000000003"
+  },
+  "twitch.chat_message_held_updated": {
+    user: nordlicht,
+    status: "denied",
+    messageId: "00000000-0000-0000-0000-000000000003"
+  },
+  "twitch.shared_chat_started": { sessionId: "shared-1", participants: 2 },
+  "twitch.shared_chat_updated": { sessionId: "shared-1", participants: 3 },
+  "twitch.shared_chat_ended": { sessionId: "shared-1" },
+  "twitch.guest_star_session_started": { sessionId: "guest-1" },
+  "twitch.guest_star_session_ended": { sessionId: "guest-1" },
+  "twitch.guest_star_guest_updated": { sessionId: "guest-1", user: sophieplays, state: "live", slotId: "1" },
+  "twitch.guest_star_settings_updated": { slotCount: 4, groupLayout: "tiled" },
+  "seventv.emote_added": { emote, actor: "FrostByte" },
+  "seventv.emote_removed": { emote, actor: "FrostByte" },
+  "seventv.emote_renamed": { emote, oldName: "peepoHi", actor: "FrostByte" },
+  "seventv.emote_set_changed": { setId: "01H000000000000000000000", name: "Kanal-Emotes", actor: "FrostByte" },
+  "streamelements.tip": {
+    name: "SophiePlays",
+    amount: { value: 5, currency: "EUR" },
+    message: "Für den nächsten Kaffee",
+    tipId: "tip-1"
+  },
+  "subs.updated": { total: 312, points: 340, at: "2026-01-01T20:00:00.000Z" },
+  "spotify.now_playing": {
+    playing: true,
+    progressMs: 42000,
+    at: "2026-01-01T20:00:00.000Z",
+    track: null,
+    addedBy: null
+  },
+  "tts.ready": {
+    id: "00000000-0000-0000-0000-000000000004",
+    voice: "Vicki",
+    text: "SophiePlays hat 5 Euro gespendet: Für den nächsten Kaffee",
+    source: "tip",
+    eventId: null
+  },
+  "tts.skip": { id: null },
+  "tts.clear": {}
+};
+// src/api-types/api-scopes.ts
+function apiScopeForEvent(event) {
+  if (event.startsWith("twitch.") || event.startsWith("stream.") || event.startsWith("streamelements.") || event.startsWith("seventv."))
+    return "events:read";
+  if (event.startsWith("state."))
+    return "states:read";
+  if (event.startsWith("tts."))
+    return "tts:read";
+  if (event.startsWith("subs."))
+    return "subs:read";
+  if (event.startsWith("spotify."))
+    return "spotify:read";
+  return null;
+}
+// src/api-types/widgets.ts
+var STREAMDECK_SCRIPT_LIMITS = {
+  sourceBytes: 256 * 1024,
+  callMs: 50,
+  evalMs: 200,
+  memoryBytes: 32 * 1024 * 1024,
+  stackBytes: 256 * 1024,
+  outputBytes: 512 * 1024,
+  images: 64,
+  failures: 5
+};
+// src/chat.ts
+function emoteUrl2(emote, size = 1) {
+  const id = encodeURIComponent(emote.id);
+  switch (emote.provider) {
+    case "twitch":
+      return `https://static-cdn.jtvnw.net/emoticons/v2/${id}/${emote.animated ? "default" : "static"}/dark/${size === 4 ? 3 : size}.0`;
+    case "7tv":
+      return `https://cdn.7tv.app/emote/${id}/${size}x.webp`;
+    case "bttv":
+      return `https://cdn.betterttv.net/emote/${id}/${size === 4 ? 3 : size}x.webp`;
+    case "ffz":
+      return `https://cdn.frankerfacez.com/emote/${id}/${size}`;
+  }
+}
+var ESCAPES = { "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;", "'": "&#39;" };
+function escapeHtml2(text) {
+  return text.replace(/[&<>"']/g, (c) => ESCAPES[c]);
+}
+function emoteImg(e, size) {
+  const name = escapeHtml2(e.name);
+  return `<img class="pixl-emote" src="${escapeHtml2(emoteUrl2(e, size))}" alt="${name}" data-provider="${e.provider}" data-emote="${escapeHtml2(e.id)}">`;
+}
+function chatHtml2(text, emotes = {}, options = {}) {
+  const size = options.size ?? 2;
+  const parts = text.split(/(\s+)/);
+  const out = [];
+  let lastEmote = -1;
+  for (const part of parts) {
+    if (!part)
+      continue;
+    if (/^\s+$/.test(part)) {
+      out.push(escapeHtml2(part));
+      continue;
+    }
+    const emote = Object.prototype.hasOwnProperty.call(emotes, part) ? emotes[part] : undefined;
+    if (!emote) {
+      out.push(escapeHtml2(part));
+      lastEmote = -1;
+      continue;
+    }
+    if (emote.zeroWidth && lastEmote >= 0) {
+      out.length = lastEmote + 1;
+      const base = out[lastEmote];
+      const inner = base.startsWith('<span class="pixl-emote-stack">') ? base.slice(31, -7) : base;
+      out[lastEmote] = `<span class="pixl-emote-stack">${inner}${emoteImg(emote, size)}</span>`;
+      continue;
+    }
+    out.push(emoteImg(emote, size));
+    lastEmote = out.length - 1;
+  }
+  return out.join("");
+}
+function badgesHtml2(badges = []) {
+  return badges.map((b) => `<img class="pixl-badge" src="${escapeHtml2(b.url)}" alt="${escapeHtml2(b.title)}" data-provider="${b.provider}">`).join("");
+}
+var CHAT_CSS2 = `.pixl-emote{height:1.75em;vertical-align:middle;margin:-.25em 0}
+.pixl-emote-stack{display:inline-grid;vertical-align:middle}
+.pixl-emote-stack>.pixl-emote{grid-area:1/1;justify-self:center;align-self:center;margin:0}
+.pixl-badge{height:1.1em;vertical-align:middle;margin-right:.25em}`;
+function layerCss(l) {
+  switch (l.type) {
+    case "linear-gradient":
+    case "radial-gradient": {
+      const stops = l.stops.map((s) => `${s.color} ${Math.round(s.at * 1000) / 10}%`).join(", ");
+      const fn = `${l.repeating ? "repeating-" : ""}${l.type}`;
+      return l.type === "linear-gradient" ? `${fn}(${l.angle}deg, ${stops})` : `${fn}(${l.shape}, ${stops})`;
+    }
+    case "color":
+      return `linear-gradient(${l.color}, ${l.color})`;
+    case "image":
+      return `url("${l.url.replace(/"/g, "%22")}")`;
+  }
+}
+function paintCss2(paint, fallback = "inherit") {
+  const layers = paint.layers.filter((l) => l.opacity > 0);
+  if (!layers.length)
+    return `color:${fallback}`;
+  const shadows = paint.shadows.map((s) => `drop-shadow(${s.x}px ${s.y}px ${s.blur}px ${s.color})`).join(" ");
+  return [
+    `color:${fallback}`,
+    `background-image:${layers.map(layerCss).join(", ")}`,
+    "background-size:cover",
+    "-webkit-background-clip:text",
+    "background-clip:text",
+    "-webkit-text-fill-color:transparent",
+    shadows ? `filter:${shadows}` : ""
+  ].filter(Boolean).join(";");
+}
+
+class PixlChat2 {
+  pixl;
+  paints = new Map;
+  queue = new Map;
+  timer = null;
+  constructor(pixl) {
+    this.pixl = pixl;
+  }
+  css = CHAT_CSS2;
+  emoteUrl(emote, size = 1) {
+    return emoteUrl2(emote, size);
+  }
+  badgesHtml(badges) {
+    return badgesHtml2(badges);
+  }
+  paintCss(paint, fallback) {
+    return paintCss2(paint, fallback);
+  }
+  html(text, emotes, options) {
+    return chatHtml2(text, emotes, options);
+  }
+  async emotes() {
+    const res = await this.pixl.request("/emotes");
+    return res.emotes;
+  }
+  paint(id) {
+    let p = this.paints.get(id);
+    if (!p) {
+      p = new Promise((resolve) => {
+        this.queue.set(id, resolve);
+        this.timer ??= setTimeout(() => this.flush(), 20);
+      });
+      this.paints.set(id, p);
+    }
+    return p;
+  }
+  async paintStyle(id, fallback = "inherit") {
+    const paint = id ? await this.paint(id) : null;
+    return paint ? paintCss2(paint, fallback) : `color:${fallback}`;
+  }
+  async flush() {
+    this.timer = null;
+    const batch = this.queue;
+    this.queue = new Map;
+    const ids = [...batch.keys()];
+    const found = new Map;
+    try {
+      for (let i = 0;i < ids.length; i += 100) {
+        const res = await this.pixl.request("/7tv/paints", {
+          query: { ids: ids.slice(i, i + 100).join(",") }
+        });
+        for (const p of res.paints)
+          found.set(p.id, p);
+      }
+    } catch (e) {
+      console.warn("[pixl] 7TV-Paints nicht geladen:", e);
+      for (const id of ids)
+        this.paints.delete(id);
+    }
+    for (const [id, resolve] of batch)
+      resolve(found.get(id) ?? null);
+  }
+}
+
+// src/errors.ts
+class PixlError2 extends Error {
+  code;
+  status;
+  scope;
+  problem;
+  constructor(code, message, extra = {}) {
+    super(message);
+    this.name = "PixlError";
+    this.code = code;
+    this.status = extra.status;
+    this.scope = extra.scope;
+    this.problem = extra.problem;
+  }
+}
+async function errorFromResponse(res) {
+  const body = await res.json().catch(() => null);
+  const message = body?.error ?? `HTTP ${res.status}`;
+  const extra = { status: res.status, problem: body?.problem, scope: body?.scope };
+  if (body?.code === "module_disabled")
+    return new PixlError2("module_disabled", message, extra);
+  if (body?.code === "missing_scope" || body?.scope)
+    return new PixlError2("missing_scope", message, extra);
+  switch (res.status) {
+    case 400:
+    case 422:
+      return new PixlError2("invalid", message, extra);
+    case 401:
+      return new PixlError2("unauthorized", message, extra);
+    case 403:
+      return new PixlError2("forbidden", message, extra);
+    case 404:
+      return new PixlError2("not_found", message, extra);
+    case 429:
+      return new PixlError2("rate_limited", message, extra);
+    default:
+      return new PixlError2("server", message, extra);
+  }
+}
+
+// src/live-value.ts
+class WritableLiveValue {
+  current;
+  listeners = new Set;
+  constructor(initial) {
+    this.current = initial;
+  }
+  get value() {
+    return this.current;
+  }
+  subscribe(fn) {
+    this.listeners.add(fn);
+    safeCall(() => fn(this.current));
+    return () => {
+      this.listeners.delete(fn);
+    };
+  }
+  set(value) {
+    if (Object.is(value, this.current))
+      return;
+    this.current = value;
+    for (const fn of [...this.listeners])
+      safeCall(() => fn(value));
+  }
+  clear() {
+    this.listeners.clear();
+  }
+}
+function safeCall(fn) {
+  try {
+    fn();
+  } catch (e) {
+    console.error("[pixl] Fehler in einem Handler:", e);
+  }
+}
+
+// src/feed.ts
+var HISTORY_OVERLAP_MS = 5 * 60000;
+var HISTORY_RETRY_DELAYS_MS = [2000, 5000, 1e4, 30000];
+var MAX_DELIVERED_IDS = 5000;
+
+class EventFeed2 {
+  pixl;
+  events;
+  handler;
+  ready;
+  error;
+  readyValue = new WritableLiveValue(false);
+  errorValue = new WritableLiveValue(null);
+  since;
+  types;
+  delivered = new Set;
+  buffer = null;
+  loadSeq = 0;
+  stopped = false;
+  latestAt = null;
+  retryTimer = null;
+  retryAttempt = 0;
+  unsubscribe = [];
+  constructor(pixl, events, options, handler) {
+    this.pixl = pixl;
+    this.events = events;
+    this.handler = handler;
+    if (options?.since === undefined)
+      throw new PixlError2("invalid", "pixl.events.feed: `since` fehlt");
+    this.ready = this.readyValue;
+    this.error = this.errorValue;
+    this.since = options.since instanceof Date ? options.since.toISOString() : String(options.since);
+    this.types = options.types?.length ? new Set(options.types) : null;
+    this.unsubscribe.push(pixl.on("*", (e) => this.handleLive(e)));
+    this.unsubscribe.push(pixl.status.subscribe((status) => {
+      if (status === "connected") {
+        this.retryAttempt = 0;
+        this.load();
+      }
+    }));
+  }
+  stop() {
+    this.stopped = true;
+    this.clearRetry();
+    for (const off of this.unsubscribe)
+      off();
+    this.buffer = null;
+  }
+  async load() {
+    const seq = ++this.loadSeq;
+    this.clearRetry();
+    this.buffer = [];
+    let failed = null;
+    try {
+      const history = await this.fetchHistory();
+      if (seq !== this.loadSeq || this.stopped)
+        return;
+      this.errorValue.set(null);
+      this.retryAttempt = 0;
+      for (const e of history)
+        this.deliver(e);
+    } catch (e) {
+      if (seq !== this.loadSeq || this.stopped)
+        return;
+      failed = e instanceof PixlError2 ? e : new PixlError2("network", String(e));
+      this.errorValue.set(failed);
+    }
+    const pending = this.buffer ?? [];
+    this.buffer = null;
+    this.readyValue.set(true);
+    for (const event of pending)
+      this.deliver(event);
+    if (failed)
+      this.scheduleRetry(failed);
+  }
+  async fetchHistory() {
+    const stopBefore = this.latestAt === null ? null : this.latestAt - HISTORY_OVERLAP_MS;
+    const all = [];
+    let cursor;
+    const query = { since: this.since, types: this.types ? [...this.types] : undefined };
+    do {
+      const page = await this.events.fetchPage(query, cursor);
+      all.push(...page.events);
+      cursor = page.nextCursor ?? undefined;
+      const oldest = page.events[page.events.length - 1];
+      if (stopBefore !== null && oldest && Date.parse(oldest.at) < stopBefore)
+        break;
+    } while (cursor);
+    return all.reverse();
+  }
+  scheduleRetry(error) {
+    if (error.code !== "network" && error.code !== "rate_limited" && error.code !== "server")
+      return;
+    if (this.pixl.status.value !== "connected")
+      return;
+    const base = HISTORY_RETRY_DELAYS_MS[Math.min(this.retryAttempt, HISTORY_RETRY_DELAYS_MS.length - 1)];
+    this.retryAttempt += 1;
+    this.retryTimer = setTimeout(() => {
+      this.retryTimer = null;
+      if (!this.stopped && this.pixl.status.value === "connected")
+        this.load();
+    }, base + Math.random() * base * 0.3);
+  }
+  clearRetry() {
+    if (this.retryTimer)
+      clearTimeout(this.retryTimer);
+    this.retryTimer = null;
+  }
+  handleLive(event) {
+    if (this.stopped)
+      return;
+    if (this.types && !this.types.has(event.type))
+      return;
+    if (this.buffer) {
+      this.buffer.push(event);
+      return;
+    }
+    this.deliver(event);
+  }
+  deliver(event) {
+    if (event.id) {
+      if (this.delivered.has(event.id))
+        return;
+      this.delivered.add(event.id);
+      if (this.delivered.size > MAX_DELIVERED_IDS) {
+        const drop = this.delivered.size - MAX_DELIVERED_IDS;
+        let i = 0;
+        for (const id of this.delivered) {
+          if (i++ >= drop)
+            break;
+          this.delivered.delete(id);
+        }
+      }
+    }
+    const at = Date.parse(event.at);
+    if (!Number.isNaN(at) && event.source !== "test" && (this.latestAt === null || at > this.latestAt))
+      this.latestAt = at;
+    safeCall(() => this.handler(event));
+  }
+}
+
+// src/fonts.ts
+var FONT_HOST2 = "https://fonts.bunny.net";
+var STYLES = [100, 200, 300, 400, 500, 600, 700, 800, 900].flatMap((w) => [`${w}`, `${w}i`]).join(",");
+function fontStylesheetUrl2(family) {
+  return `${FONT_HOST2}/css?family=${encodeURIComponent(family.trim())}:${STYLES}&display=swap`;
+}
+function fontFamily2(family, fallback = "sans-serif") {
+  const name = typeof family === "string" ? family.trim() : "";
+  if (!name)
+    return fallback;
+  return `"${name.replace(/["\\]/g, "\\$&")}", ${fallback}`;
+}
+var loading = new Map;
+function loadFont2(family) {
+  const name = typeof family === "string" ? family.trim() : "";
+  if (!name || typeof document === "undefined")
+    return Promise.resolve(false);
+  let done = loading.get(name);
+  if (!done) {
+    done = new Promise((resolve) => {
+      const link = document.createElement("link");
+      link.rel = "stylesheet";
+      link.href = fontStylesheetUrl2(name);
+      link.dataset.pixlFont = name;
+      link.onload = () => {
+        const fonts = document.fonts;
+        if (!fonts)
+          return resolve(true);
+        fonts.load(`16px ${fontFamily2(name)}`).then((faces) => resolve(faces.length > 0), () => resolve(false));
+      };
+      link.onerror = () => resolve(false);
+      document.head.append(link);
+    });
+    loading.set(name, done);
+  }
+  return done;
+}
+function fontsOf(state) {
+  const out = new Set;
+  const m = state?.manifest;
+  if (!state || !m)
+    return [];
+  const scan = (fields, values) => {
+    for (const [name, field] of Object.entries(fields ?? {})) {
+      const value = values[name];
+      if (field.type === "font" && typeof value === "string")
+        out.add(value.trim());
+      if (field.type !== "list" || !Array.isArray(value))
+        continue;
+      const keys = Object.entries(field.item).filter(([, f]) => f.type === "font").map(([key]) => key);
+      if (!keys.length)
+        continue;
+      for (const item of value)
+        for (const key of keys)
+          if (typeof item?.[key] === "string")
+            out.add(item[key].trim());
+    }
+  };
+  scan(m.settings, state.settings);
+  scan(m.controls, state.values);
+  out.delete("");
+  return [...out];
+}
+
+// src/tts.ts
+class PixlTts2 {
+  pixl;
+  constructor(pixl) {
+    this.pixl = pixl;
+  }
+  async speak(text, options = {}) {
+    const res = await this.pixl.fetchRaw(this.base, {
+      method: "POST",
+      body: { text, voice: options.voice, filters: options.filters },
+      signal: options.signal
+    });
+    if (res.status === 204)
+      throw new PixlError2("forbidden", "Liest die Browserquelle vor, die Vorschau spielt es mit ab", {
+        status: 204,
+        problem: "preview"
+      });
+    const spoken = await res.json();
+    if (this.pixl._preview)
+      this.pixl.sendTestEvent("tts.ready", {
+        id: spoken.id,
+        text: spoken.text,
+        voice: spoken.voice,
+        source: "api",
+        eventId: null
+      });
+    return spoken;
+  }
+  get base() {
+    return this.pixl._preview ? "/widget/preview/tts" : "/tts";
+  }
+  voices(options = {}) {
+    return this.pixl.request("/tts/voices", { signal: options.signal });
+  }
+  async audio(id, options = {}) {
+    const res = await this.pixl.fetchRaw(`${this.base}/${encodeURIComponent(id)}/audio`, { signal: options.signal });
+    return res.blob();
+  }
+  async marks(id, options = {}) {
+    const res = await this.pixl.request(`${this.base}/${encodeURIComponent(id)}/marks`, {
+      signal: options.signal
+    });
+    return res.marks;
+  }
+  player(options = {}) {
+    return new TtsPlayer2(this.pixl, this, options);
+  }
+}
+
+class TtsPlayer2 {
+  pixl;
+  tts;
+  options;
+  queue = [];
+  current = null;
+  wordFrame = null;
+  volume;
+  destroyed = false;
+  warnedAutoplay = false;
+  unsubscribe;
+  constructor(pixl, tts, options) {
+    this.pixl = pixl;
+    this.tts = tts;
+    this.options = options;
+    this.volume = clampVolume(options.volume ?? 1);
+    const onReady = (event) => {
+      const item = toItem(event);
+      if (!item || item.replay && this.options.ignoreReplays)
+        return;
+      if (this.current?.item.id === item.id || this.queue.some((q) => q.id === item.id))
+        return;
+      this.queue.push(item);
+      const max = this.options.maxQueue ?? 20;
+      if (this.queue.length > max)
+        this.queue.splice(0, this.queue.length - max);
+      this.next();
+    };
+    const onSkip = (event) => {
+      const id = event.data.id;
+      if (!id || this.current?.item.id === id)
+        this.skip();
+      else
+        this.queue = this.queue.filter((q) => q.id !== id);
+    };
+    this.unsubscribe = [
+      pixl._listen("tts.ready", onReady),
+      pixl._listen("tts.skip", onSkip),
+      pixl._listen("tts.clear", () => this.clear())
+    ];
+  }
+  skip() {
+    if (!this.current)
+      return;
+    this.current.skipped = true;
+    this.current.finish();
+  }
+  clear() {
+    this.queue = [];
+    this.skip();
+  }
+  setVolume(volume) {
+    this.volume = clampVolume(volume);
+    if (this.current?.audio)
+      this.current.audio.volume = this.volume;
+  }
+  get pending() {
+    return this.queue;
+  }
+  destroy() {
+    this.destroyed = true;
+    for (const off of this.unsubscribe)
+      off();
+    this.clear();
+  }
+  followWords(audio, item, marks) {
+    this.stopWords();
+    let next = 0;
+    const endOf = (i) => marks[i].end ?? marks[i + 1]?.start ?? (Number.isFinite(audio.duration) ? Math.round(audio.duration * 1000) : marks[i].start);
+    const tick = () => {
+      const now = audio.currentTime * 1000;
+      while (next < marks.length && marks[next].start <= now) {
+        const i = next++;
+        const word = { word: marks[i].word, index: i, start: marks[i].start, end: endOf(i) };
+        safeCall(() => this.options.onWord?.(word, item));
+      }
+      this.wordFrame = next < marks.length && !audio.ended ? schedule(tick) : null;
+    };
+    this.wordFrame = schedule(tick);
+  }
+  stopWords() {
+    if (this.wordFrame !== null)
+      cancel(this.wordFrame);
+    this.wordFrame = null;
+  }
+  async next() {
+    if (this.current || this.destroyed)
+      return;
+    const item = this.queue.shift();
+    if (!item)
+      return;
+    let done = false;
+    let resolveDone;
+    const finished = new Promise((r) => resolveDone = r);
+    const slot = {
+      item,
+      audio: null,
+      url: null,
+      skipped: false,
+      finish: () => {
+        if (done)
+          return;
+        done = true;
+        this.stopWords();
+        slot.audio?.pause();
+        if (slot.url)
+          URL.revokeObjectURL(slot.url);
+        resolveDone();
+      }
+    };
+    this.current = slot;
+    try {
+      const [blob, marks] = await Promise.all([
+        this.tts.audio(item.id),
+        this.options.onWord ? this.tts.marks(item.id).catch((e) => {
+          console.warn("[pixl] Zeitmarken nicht verfügbar, onWord bleibt für diesen Eintrag stumm:", e);
+          return;
+        }) : Promise.resolve(undefined)
+      ]);
+      if (marks)
+        item.marks = marks;
+      if (!done) {
+        slot.url = URL.createObjectURL(blob);
+        const audio = new Audio(slot.url);
+        audio.volume = this.volume;
+        audio.addEventListener("ended", slot.finish);
+        audio.addEventListener("error", slot.finish);
+        slot.audio = audio;
+        safeCall(() => this.options.onStart?.(item));
+        if (marks?.length)
+          this.followWords(audio, item, marks);
+        await audio.play().catch((e) => {
+          if (!this.warnedAutoplay && e instanceof DOMException && e.name === "NotAllowedError") {
+            this.warnedAutoplay = true;
+            console.warn("[pixl] Der Browser blockiert die Wiedergabe ohne Klick. In OBS und StreamElements passiert das nicht, im normalen Browser einmal auf die Seite klicken.");
+          }
+          slot.finish();
+        });
+      }
+    } catch (e) {
+      console.error("[pixl] TTS-Audio konnte nicht geladen werden:", e);
+      slot.finish();
+    }
+    await finished;
+    safeCall(() => this.options.onEnd?.(item, { skipped: slot.skipped }));
+    this.current = null;
+    if (this.queue.length && !this.destroyed) {
+      setTimeout(() => void this.next(), this.options.gapMs ?? 500);
+    }
+  }
+}
+function schedule(fn) {
+  return typeof requestAnimationFrame === "function" ? requestAnimationFrame(fn) : setTimeout(fn, 30);
+}
+function cancel(handle) {
+  if (typeof cancelAnimationFrame === "function")
+    cancelAnimationFrame(handle);
+  else
+    clearTimeout(handle);
+}
+function toItem(event) {
+  const d = event.data;
+  if (!d.id)
+    return null;
+  return {
+    id: d.id,
+    text: d.text,
+    voice: d.voice,
+    source: d.source,
+    ...d.eventId ? { eventId: d.eventId } : {},
+    ...d.textTruncated === true ? { textTruncated: true } : {},
+    replay: event.source === "replay"
+  };
+}
+function clampVolume(v) {
+  return Number.isFinite(v) ? Math.min(1, Math.max(0, v)) : 1;
+}
+
+// src/bindings.ts
+function cssVarName(name) {
+  return `--pixl-${name.replace(/([a-z0-9])([A-Z])/g, "$1-$2").replace(/_/g, "-").toLowerCase()}`;
+}
+function cssString(text) {
+  return `"${text.replace(/[\\"]/g, "\\$&").replace(/\n/g, "\\a ")}"`;
+}
+function bindable(field) {
+  if (field.type === "list" || field.type === "trigger" || field.type === "voice")
+    return false;
+  return !(field.type === "string" && field.sensitive);
+}
+function cssValue(field, value, fileUrl) {
+  if (!bindable(field) || value === undefined || value === null)
+    return null;
+  switch (field.type) {
+    case "number":
+      return typeof value === "number" && Number.isFinite(value) ? String(value) : null;
+    case "boolean":
+      return value === true ? "1" : "0";
+    case "string":
+      return typeof value === "string" ? cssString(value) : null;
+    case "font":
+      return typeof value === "string" && value ? fontFamily2(value) : null;
+    case "file":
+      return typeof value === "string" && value ? `url(${cssString(fileUrl(value))})` : null;
+    case "color":
+    case "enum":
+      return typeof value === "string" && value ? value : null;
+  }
+}
+function bindableFields(state) {
+  const out = new Map;
+  const add = (fields, values) => {
+    for (const [name, field] of Object.entries(fields ?? {}))
+      if (!out.has(name) && bindable(field))
+        out.set(name, { field, value: values[name] });
+  };
+  add(state.manifest?.controls, state.values);
+  add(state.manifest?.settings, state.settings);
+  return out;
+}
+
+class PageBindings {
+  doc;
+  fileUrl;
+  vars = new Set;
+  constructor(doc, fileUrl) {
+    this.doc = doc;
+    this.fileUrl = fileUrl;
+  }
+  apply(state) {
+    const style = this.doc.documentElement.style;
+    const next = new Set;
+    for (const [name, { field, value }] of bindableFields(state)) {
+      const css = cssValue(field, value, this.fileUrl);
+      if (css === null)
+        continue;
+      const prop = cssVarName(name);
+      next.add(prop);
+      if (style.getPropertyValue(prop) !== css)
+        style.setProperty(prop, css);
+    }
+    for (const prop of this.vars)
+      if (!next.has(prop))
+        style.removeProperty(prop);
+    this.vars = next;
+  }
+}
+
+// src/widget.ts
+class PixlWidget2 {
+  pixl;
+  state;
+  stateValue;
+  fieldValues = new Map;
+  actionHandlers = new Map;
+  listHandlers = new Map;
+  fields;
+  values;
+  settings;
+  files = {
+    list: () => this.pixl.request("/widget/files"),
+    upload: (file, name) => this.pixl.request("/widget/files", {
+      method: "POST",
+      query: { name: name ?? (file instanceof File ? file.name : "datei") },
+      raw: file
+    }).then((r) => ({ ...r, url: this.fileUrl(r.path) }))
+  };
+  voicesCache = null;
+  voices() {
+    const now = Date.now();
+    if (!this.voicesCache || now - this.voicesCache.at > 30000) {
+      const promise = this.pixl.request("/widget/voices");
+      this.voicesCache = { at: now, promise };
+      promise.catch(() => {
+        if (this.voicesCache?.promise === promise)
+          this.voicesCache = null;
+      });
+    }
+    return this.voicesCache.promise;
+  }
+  preview;
+  bindings;
+  constructor(pixl, initial, options = {}) {
+    this.pixl = pixl;
+    this.preview = options.preview === true;
+    this.bindings = options.bind && typeof document !== "undefined" ? new PageBindings(document, (p) => this.fileUrl(p)) : null;
+    if (initial)
+      this.bindings?.apply(initial);
+    this.stateValue = new WritableLiveValue(initial);
+    this.state = this.stateValue;
+    loadFonts(initial);
+    this.values = this.fieldProxy("controls");
+    this.settings = this.fieldProxy("settings");
+    this.fields = fieldsView(() => this.stateValue.value);
+  }
+  fileUrl(path) {
+    if (!path.startsWith("/files/"))
+      return path;
+    const origin = globalThis.__PIXL__?.widgetOrigin;
+    return origin ? `${origin.replace(/\/+$/, "")}${path}` : path;
+  }
+  get manifest() {
+    return this.stateValue.value?.manifest ?? null;
+  }
+  get(name) {
+    const s = this.stateValue.value;
+    return s && name in s.values ? s.values[name] : s?.settings[name];
+  }
+  on(action, handler) {
+    let set = this.actionHandlers.get(action);
+    if (!set)
+      this.actionHandlers.set(action, set = new Set);
+    set.add(handler);
+    return () => {
+      set.delete(handler);
+    };
+  }
+  onList(name, handler) {
+    let set = this.listHandlers.get(name);
+    if (!set)
+      this.listHandlers.set(name, set = new Set);
+    set.add(handler);
+    return () => {
+      set.delete(handler);
+    };
+  }
+  set(name, value) {
+    return this.batch([{ name, set: value }]);
+  }
+  add(name, delta) {
+    return this.batch([{ name, add: delta }]);
+  }
+  toggle(name) {
+    return this.batch([{ name, toggle: true }]);
+  }
+  press(name) {
+    return this.batch([{ name, press: true }]);
+  }
+  list(name) {
+    return {
+      insert: (item, at) => this.batch([{ name, insert: item, ...at === undefined ? {} : { at } }]),
+      update: (id, patch) => this.batch([{ name, update: id, patch }]),
+      remove: (id) => this.batch([{ name, remove: id }]),
+      move: (id, to) => this.batch([{ name, move: id, to }]),
+      replace: (items) => this.batch([{ name, set: items }])
+    };
+  }
+  async batch(operations) {
+    if (this.preview)
+      return this.previewBatch(operations);
+    const result = await this.pixl.request("/widget", {
+      method: "POST",
+      body: { operations }
+    });
+    if (this.pixl.status.value !== "connected")
+      this.applyState(result.state, result.changes);
+  }
+  async previewBatch(operations) {
+    const current = this.stateValue.value;
+    if (!current)
+      return;
+    const result = await this.pixl.request("/widget/preview", {
+      method: "POST",
+      body: { operations, settings: current.settings, values: current.values }
+    });
+    const latest = this.stateValue.value ?? current;
+    const next = { ...latest, values: { ...latest.values }, settings: { ...latest.settings } };
+    for (const change of result.changes)
+      applyChange(next, change);
+    if (result.changes.length)
+      this.applyState(next, result.changes);
+    for (const name of result.actions)
+      for (const h of [...this.actionHandlers.get(name) ?? []])
+        safeCall(h);
+  }
+  fromServer(state) {
+    const own = this.stateValue.value;
+    if (!this.preview || !own)
+      return state;
+    return {
+      ...state,
+      version: own.version,
+      manifest: own.manifest,
+      settings: mergeKnown(own, state, "settings"),
+      values: mergeKnown(own, state, "controls")
+    };
+  }
+  async _refetch() {
+    this.applyState(this.fromServer(await this.pixl.request("/widget")), null);
+  }
+  _setState(state) {
+    this.applyState(this.fromServer(state), null);
+  }
+  _handle(message) {
+    if (message.type === "widget.action") {
+      for (const h of [...this.actionHandlers.get(message.name) ?? []])
+        safeCall(h);
+      return;
+    }
+    if (message.type === "widget.version")
+      return;
+    if (message.refetch) {
+      this._refetch().catch((e) => console.warn("[pixl] Widget-Stand nicht geladen:", e));
+      return;
+    }
+    const current = this.stateValue.value;
+    if (!current)
+      return;
+    const next = { ...current, values: { ...current.values }, settings: { ...current.settings } };
+    for (const change of message.changes)
+      applyChange(next, change);
+    this.applyState(next, message.changes);
+  }
+  applyState(state, changes) {
+    const previous = this.stateValue.value;
+    loadFonts(state);
+    this.stateValue.set(state);
+    this.bindings?.apply(state);
+    for (const [key, live] of this.fieldValues) {
+      const [scope, name] = splitKey(key);
+      live.set((scope === "settings" ? state.settings : state.values)[name]);
+    }
+    const handled = new Set;
+    for (const change of changes ?? []) {
+      const handlers = this.listHandlers.get(change.name);
+      if (!handlers?.size)
+        continue;
+      const before = listOf(previous, change);
+      const event = listChange(change, before);
+      if (!event)
+        continue;
+      handled.add(change.name);
+      for (const h of [...handlers])
+        safeCall(() => h(event));
+    }
+    for (const [name, handlers] of this.listHandlers) {
+      if (handled.has(name))
+        continue;
+      const items = state.values[name] ?? state.settings[name];
+      const before = previous ? previous.values[name] ?? previous.settings[name] : undefined;
+      if (!Array.isArray(items) || before === items || JSON.stringify(before) === JSON.stringify(items))
+        continue;
+      for (const h of [...handlers])
+        safeCall(() => h({ type: "replace", items }));
+    }
+  }
+  fieldProxy(scope) {
+    return new Proxy({}, {
+      get: (_, name) => {
+        if (typeof name !== "string")
+          return;
+        const key = `${scope}:${name}`;
+        let live = this.fieldValues.get(key);
+        if (!live) {
+          const s = this.stateValue.value;
+          live = new WritableLiveValue(s ? (scope === "settings" ? s.settings : s.values)[name] : undefined);
+          this.fieldValues.set(key, live);
+        }
+        return live;
+      },
+      ownKeys: () => {
+        const s = this.stateValue.value;
+        return Object.keys(s ? scope === "settings" ? s.settings : s.values : {});
+      },
+      getOwnPropertyDescriptor: () => ({ enumerable: true, configurable: true })
+    });
+  }
+}
+function fieldsView(state) {
+  const names = () => {
+    const s = state();
+    return s ? [...new Set([...Object.keys(s.values), ...Object.keys(s.settings)])] : [];
+  };
+  const read = (name) => {
+    const s = state();
+    return s && name in s.values ? s.values[name] : s?.settings[name];
+  };
+  return new Proxy({}, {
+    get: (_, name) => typeof name === "string" ? read(name) : undefined,
+    has: (_, name) => typeof name === "string" && names().includes(name),
+    ownKeys: () => names(),
+    getOwnPropertyDescriptor: (_, name) => typeof name === "string" && names().includes(name) ? { value: read(name), writable: false, enumerable: true, configurable: true } : undefined,
+    set: (_, name) => {
+      throw new TypeError(`[pixl] fields ist nur zum Lesen, ändern geht mit widget.set("${String(name)}", …)`);
+    },
+    deleteProperty: () => false
+  });
+}
+function loadFonts(state) {
+  for (const font of fontsOf(state))
+    loadFont2(font);
+}
+function mergeKnown(own, server, scope) {
+  const mine = (scope === "settings" ? own.manifest?.settings : own.manifest?.controls) ?? {};
+  const theirs = (scope === "settings" ? server.manifest?.settings : server.manifest?.controls) ?? {};
+  const out = { ...bucket(own, scope) };
+  const values = bucket(server, scope);
+  for (const [name, field] of Object.entries(mine))
+    if (theirs[name]?.type === field.type && name in values)
+      out[name] = values[name];
+  return out;
+}
+function splitKey(key) {
+  const i = key.indexOf(":");
+  return [key.slice(0, i), key.slice(i + 1)];
+}
+function bucket(state, scope) {
+  return scope === "settings" ? state.settings : state.values;
+}
+function listOf(state, change) {
+  if (!state)
+    return [];
+  const v = bucket(state, change.scope)[change.name];
+  return Array.isArray(v) ? v : [];
+}
+function applyChange(state, change) {
+  const target = bucket(state, change.scope);
+  if ("value" in change) {
+    target[change.name] = change.value;
+    return;
+  }
+  const list = Array.isArray(target[change.name]) ? [...target[change.name]] : [];
+  if ("inserted" in change) {
+    if (!list.some((x) => x.id === change.inserted.id))
+      list.splice(change.at, 0, change.inserted);
+  } else if ("updated" in change) {
+    const i = list.findIndex((x) => x.id === change.updated.id);
+    if (i >= 0)
+      list[i] = change.updated;
+  } else if ("removed" in change) {
+    const i = list.findIndex((x) => x.id === change.removed);
+    if (i >= 0)
+      list.splice(i, 1);
+  } else if ("moved" in change) {
+    const i = list.findIndex((x) => x.id === change.moved);
+    if (i >= 0) {
+      const [item] = list.splice(i, 1);
+      list.splice(Math.min(change.to, list.length), 0, item);
+    }
+  }
+  target[change.name] = list;
+}
+function listChange(change, before) {
+  if ("inserted" in change)
+    return { type: "insert", item: change.inserted, at: change.at };
+  if ("updated" in change)
+    return { type: "update", item: change.updated, previous: before.find((x) => x.id === change.updated.id) ?? null };
+  if ("removed" in change)
+    return { type: "remove", id: change.removed, previous: before.find((x) => x.id === change.removed) ?? null };
+  if ("moved" in change)
+    return { type: "move", id: change.moved, to: change.to };
+  if (Array.isArray(change.value))
+    return { type: "replace", items: change.value };
+  return null;
+}
+
+// src/events.ts
+function toQueryDate(value) {
+  return value instanceof Date ? value.toISOString() : String(value);
+}
+
+class PixlEvents {
+  pixl;
+  constructor(pixl) {
+    this.pixl = pixl;
+  }
+  async* list(query) {
+    let cursor;
+    do {
+      const page = await this.fetchPage(query, cursor);
+      yield* page.events;
+      cursor = page.nextCursor ?? undefined;
+    } while (cursor);
+  }
+  async all(query) {
+    const all = [];
+    for await (const e of this.list(query))
+      all.push(e);
+    return all.reverse();
+  }
+  feed(options, handler) {
+    return new EventFeed2(this.pixl, this, options, handler);
+  }
+  fetchPage(query, cursor) {
+    if (this.pixl.demo)
+      return Promise.resolve({ events: [], nextCursor: null });
+    return this.pixl.request("/events", {
+      query: {
+        v: 2,
+        since: toQueryDate(query.since),
+        until: query.until !== undefined ? toQueryDate(query.until) : undefined,
+        types: query.types?.join(","),
+        limit: 200,
+        cursor
+      },
+      signal: query.signal
+    });
+  }
+}
+
+// src/frame.ts
+function startFrameBridge() {
+  if (typeof window === "undefined" || window.parent === window)
+    return;
+  const global = globalThis;
+  if (global.__pixlFrame)
+    return;
+  global.__pixlFrame = true;
+  window.addEventListener("message", (e) => {
+    if (e.source !== window.parent || typeof e.data !== "object" || !e.data)
+      return;
+    if (e.data.type !== "pixl:theme" || typeof e.data.vars !== "object")
+      return;
+    const root = document.documentElement;
+    for (const [name, value] of Object.entries(e.data.vars))
+      if (name.startsWith("--pixl-"))
+        root.style.setProperty(name, String(value));
+    if (e.data.scheme)
+      root.style.colorScheme = e.data.scheme;
+  });
+  const report = () => {
+    const body = document.body;
+    const style = getComputedStyle(body);
+    const height = body.getBoundingClientRect().height + parseFloat(style.marginTop) + parseFloat(style.marginBottom);
+    window.parent.postMessage({ type: "pixl:height", height: Math.ceil(height) }, "*");
+  };
+  const observe = () => {
+    if (typeof ResizeObserver !== "undefined")
+      new ResizeObserver(report).observe(document.body);
+    report();
+  };
+  if (document.body)
+    observe();
+  else
+    document.addEventListener("DOMContentLoaded", observe, { once: true });
+  window.addEventListener("load", report);
+}
+
+// src/spotify.ts
+class PixlSpotify {
+  pixl;
+  nowPlaying;
+  value = new WritableLiveValue(null);
+  constructor(pixl) {
+    this.pixl = pixl;
+    this.nowPlaying = this.value;
+    pixl._onConnect(() => this.load());
+    pixl._listen("spotify.now_playing", (e) => this.value.set(e.data));
+  }
+  progress(now = Date.now()) {
+    const np = this.value.value;
+    if (!np?.track)
+      return 0;
+    const ms = np.playing ? np.progressMs + (now - Date.parse(np.at)) : np.progressMs;
+    return Math.max(0, Math.min(ms, np.track.durationMs));
+  }
+  async load() {
+    if (this.pixl.demo) {
+      this.value.set({ ...EVENT_TEMPLATES2["spotify.now_playing"], at: new Date().toISOString() });
+      return;
+    }
+    if (!this.pixl.scopes?.includes("spotify:read"))
+      return;
+    try {
+      this.value.set(await this.pixl.request("/spotify/now-playing"));
+    } catch (e) {
+      if (e instanceof PixlError2 && e.code === "module_disabled")
+        this.value.set(null);
+    }
+  }
+  _close() {
+    this.value.clear();
+  }
+}
+
+// src/streamelements.ts
+class PixlStreamElements {
+  pixl;
+  constructor(pixl) {
+    this.pixl = pixl;
+  }
+  get(path, params = {}, options = {}) {
+    return this.pixl.request(`/streamelements/${path}`, { query: params, signal: options.signal });
+  }
+}
+
+// src/stream.ts
+var RECONNECT_DELAYS_MS = [500, 1000, 2000, 3000, 5000, 1e4];
+var WATCHDOG_MS = 45000;
+var CONNECT_TIMEOUT_MS = 15000;
+
+class LiveStream {
+  options;
+  abort = null;
+  reconnectTimer = null;
+  watchdog = null;
+  attempt = 0;
+  stopped = true;
+  everConnected = false;
+  lostAt = null;
+  constructor(options) {
+    this.options = options;
+  }
+  start() {
+    if (this.abort)
+      return;
+    this.stopped = false;
+    this.run();
+  }
+  stop() {
+    this.stopped = true;
+    if (this.reconnectTimer)
+      clearTimeout(this.reconnectTimer);
+    this.reconnectTimer = null;
+    this.clearWatchdog();
+    this.abort?.abort();
+    this.abort = null;
+    this.options.onStatus("closed");
+  }
+  async run() {
+    const abort = new AbortController;
+    this.abort = abort;
+    this.options.onStatus("connecting");
+    let fatal = false;
+    try {
+      this.watchdog = setTimeout(() => abort.abort(), CONNECT_TIMEOUT_MS);
+      const res = await (this.options.fetch ?? fetch)(this.options.url, {
+        headers: { Authorization: `Bearer ${this.options.token()}`, Accept: "text/event-stream" },
+        signal: abort.signal,
+        cache: "no-store"
+      });
+      this.clearWatchdog();
+      if (res.status === 401 || res.status === 403) {
+        fatal = true;
+        return;
+      }
+      if (!res.ok || !res.body)
+        throw new Error(`HTTP ${res.status}`);
+      this.attempt = 0;
+      if (this.lostAt !== null)
+        this.options.log(`Live-Verbindung wieder da nach ${((Date.now() - this.lostAt) / 1000).toFixed(1)} s`);
+      this.lostAt = null;
+      this.everConnected = true;
+      await this.read(res.body, abort, () => {
+        fatal = true;
+      });
+    } catch {} finally {
+      this.clearWatchdog();
+      if (this.abort === abort)
+        this.abort = null;
+      if (fatal) {
+        this.options.log("Live-Verbindung abgelehnt (Zugang ungültig oder widerrufen), kein neuer Versuch");
+        this.stopped = true;
+        this.options.onStatus("unauthorized");
+      } else if (!this.stopped) {
+        if (this.lostAt === null) {
+          this.lostAt = Date.now();
+          this.options.log(this.everConnected ? "Live-Verbindung getrennt, verbinde neu" : "Live-Verbindung nicht erreichbar, versuche es weiter");
+        }
+        this.options.onStatus("disconnected");
+        this.scheduleReconnect();
+      }
+    }
+  }
+  scheduleReconnect() {
+    const base = RECONNECT_DELAYS_MS[Math.min(this.attempt, RECONNECT_DELAYS_MS.length - 1)];
+    this.attempt += 1;
+    const delay = base + Math.random() * base * 0.3;
+    this.reconnectTimer = setTimeout(() => {
+      this.reconnectTimer = null;
+      if (!this.stopped)
+        this.start();
+    }, delay);
+  }
+  armWatchdog(abort) {
+    this.clearWatchdog();
+    this.watchdog = setTimeout(() => abort.abort(), WATCHDOG_MS);
+  }
+  clearWatchdog() {
+    if (this.watchdog)
+      clearTimeout(this.watchdog);
+    this.watchdog = null;
+  }
+  async read(body, abort, onRevoked) {
+    const reader = body.getReader();
+    const decoder = new TextDecoder;
+    let buffer = "";
+    let dataLines = [];
+    this.armWatchdog(abort);
+    for (;; ) {
+      const { value, done } = await reader.read();
+      if (done)
+        return;
+      this.armWatchdog(abort);
+      buffer += decoder.decode(value, { stream: true });
+      let newline;
+      while ((newline = buffer.indexOf(`
+`)) >= 0) {
+        const line = buffer.slice(0, newline).replace(/\r$/, "");
+        buffer = buffer.slice(newline + 1);
+        if (line === "") {
+          if (!dataLines.length)
+            continue;
+          const raw = dataLines.join(`
+`);
+          dataLines = [];
+          let message;
+          try {
+            message = JSON.parse(raw);
+          } catch {
+            continue;
+          }
+          if (message.type === "access_revoked") {
+            onRevoked();
+            await reader.cancel().catch(() => {});
+            return;
+          }
+          this.options.onMessage(message);
+        } else if (line.startsWith("data:")) {
+          dataLines.push(line.slice(5).replace(/^ /, ""));
+        }
+      }
+    }
+  }
+}
+
+// src/twitch.ts
+class PixlTwitch {
+  pixl;
+  subs;
+  hypeTrain;
+  poll;
+  prediction;
+  goal;
+  charity;
+  adBreak;
+  values = {
+    subs: new WritableLiveValue(null),
+    hypeTrain: new WritableLiveValue(null),
+    poll: new WritableLiveValue(null),
+    prediction: new WritableLiveValue(null),
+    goal: new WritableLiveValue(null),
+    charity: new WritableLiveValue(null),
+    adBreak: new WritableLiveValue(null)
+  };
+  adBreakTimer = null;
+  constructor(pixl) {
+    this.pixl = pixl;
+    const v = this.values;
+    this.subs = v.subs;
+    this.hypeTrain = v.hypeTrain;
+    this.poll = v.poll;
+    this.prediction = v.prediction;
+    this.goal = v.goal;
+    this.charity = v.charity;
+    this.adBreak = v.adBreak;
+    pixl._onConnect(() => this.load());
+    pixl._listen("subs.updated", (e) => v.subs.set(e.data));
+    pixl._listen("twitch.hype_train_started", (e) => v.hypeTrain.set(e.data));
+    pixl._listen("twitch.hype_train_progress", (e) => v.hypeTrain.set(e.data));
+    pixl._listen("twitch.hype_train_ended", () => v.hypeTrain.set(null));
+    pixl._listen("twitch.poll_started", (e) => v.poll.set({ ...e.data, status: "active" }));
+    pixl._listen("twitch.poll_progress", (e) => v.poll.set({ ...e.data, status: "active" }));
+    pixl._listen("twitch.poll_ended", (e) => v.poll.set(e.data));
+    pixl._listen("twitch.prediction_started", (e) => v.prediction.set({ ...e.data, status: "active", winner: null }));
+    pixl._listen("twitch.prediction_progress", (e) => v.prediction.set({ ...e.data, status: "active", winner: null }));
+    pixl._listen("twitch.prediction_locked", (e) => v.prediction.set({ ...e.data, status: "locked", winner: null }));
+    pixl._listen("twitch.prediction_ended", (e) => v.prediction.set(e.data));
+    pixl._listen("twitch.goal_started", (e) => v.goal.set({ ...e.data, active: true, achieved: false }));
+    pixl._listen("twitch.goal_progress", (e) => {
+      const prev = v.goal.value;
+      v.goal.set({
+        type: prev?.type ?? "",
+        description: prev?.description ?? "",
+        ...e.data,
+        active: true,
+        achieved: false
+      });
+    });
+    pixl._listen("twitch.goal_ended", (e) => v.goal.set({ ...e.data, active: false }));
+    pixl._listen("twitch.charity_started", (e) => v.charity.set({ ...e.data, current: { value: 0, currency: e.data.target.currency }, active: true }));
+    pixl._listen("twitch.charity_progress", (e) => v.charity.set({ charity: v.charity.value?.charity ?? "", ...e.data, active: true }));
+    pixl._listen("twitch.charity_stopped", (e) => v.charity.set({ ...e.data, active: false }));
+    pixl._listen("twitch.ad_break", (e) => {
+      const startedAt = e.data.startedAt ?? e.at;
+      const endsAt = new Date(Date.parse(startedAt) + e.data.durationSec * 1000);
+      v.adBreak.set({ durationSec: e.data.durationSec, startedAt, endsAt: endsAt.toISOString() });
+      if (this.adBreakTimer)
+        clearTimeout(this.adBreakTimer);
+      this.adBreakTimer = setTimeout(() => v.adBreak.set(null), Math.max(0, endsAt.getTime() - Date.now()));
+    });
+  }
+  async fetchSubs(options = {}) {
+    const subs = await this.pixl.request("/subs", { signal: options.signal });
+    this.values.subs.set(subs);
+    return subs;
+  }
+  async load() {
+    if (this.pixl.demo) {
+      this.values.subs.set(EVENT_TEMPLATES2["subs.updated"]);
+      return;
+    }
+    if (this.pixl.scopes?.includes("subs:read"))
+      await this.fetchSubs().catch(() => {});
+  }
+  _close() {
+    if (this.adBreakTimer)
+      clearTimeout(this.adBreakTimer);
+    for (const value of Object.values(this.values))
+      value.clear();
+  }
+}
+
+// src/client.ts
+var DEFAULT_BASE_URL = "https://pixl.lennox.zip";
+var DEMO_CHANNEL = { id: "demo", name: "Demo-Kanal", login: "pixl", avatar: null };
+var ALL_SCOPES = ["events:read", "tts:read", "tts:write", "subs:read", "spotify:read", "streamelements:read"];
+function injected() {
+  const fromPage = globalThis.__PIXL__;
+  if (fromPage)
+    return fromPage;
+  const hash = typeof location !== "undefined" ? location.hash.slice(1) : "";
+  if (!hash.includes("pixl-key="))
+    return;
+  const params = new URLSearchParams(hash);
+  return { key: params.get("pixl-key") ?? undefined, baseUrl: params.get("pixl-server") ?? undefined };
+}
+
+class Pixl2 {
+  static defaultBaseUrl;
+  static sharedInstance = null;
+  static shared(options) {
+    return Pixl2.sharedInstance ??= new Pixl2(options);
+  }
+  static loadFont = loadFont2;
+  static fontFamily = fontFamily2;
+  baseUrl;
+  demo;
+  status;
+  channel;
+  ready;
+  events;
+  twitch;
+  spotify;
+  tts;
+  chat;
+  streamElements;
+  fields = fieldsView(() => this.widgetInstance?.state.value ?? null);
+  key;
+  logs;
+  widgetInstance = null;
+  control;
+  previewMode;
+  fetchImpl;
+  stream;
+  statusValue = new WritableLiveValue("closed");
+  channelValue = new WritableLiveValue(null);
+  handlers = new Map;
+  internal = new Map;
+  connectHandlers = new Set;
+  scopeList = null;
+  warnedScopes = new Set;
+  warnedNoWidget = false;
+  resolveReady;
+  rejectReady;
+  readySettled = false;
+  constructor(options = {}) {
+    const inj = injected();
+    this.demo = options.demo === true;
+    this.key = options.key ?? inj?.key ?? "";
+    this.control = !this.key && inj?.control === true;
+    this.previewMode = this.control && inj?.preview === true;
+    if (!this.key && !this.demo && !this.control)
+      throw new PixlError2("unauthorized", "pixl: `key` fehlt (API-Schlüssel aus „API & SDK“) oder `demo: true` setzen");
+    if (inj?.widget)
+      this.widgetInstance = new PixlWidget2(this, inj.widget, this.widgetOptions());
+    this.logs = options.logs !== false;
+    Pixl2.sharedInstance ??= this;
+    this.fetchImpl = options.fetch ?? ((...args) => fetch(...args));
+    this.baseUrl = (options.baseUrl ?? inj?.baseUrl ?? Pixl2.defaultBaseUrl ?? DEFAULT_BASE_URL).replace(/\/+$/, "");
+    this.status = this.statusValue;
+    this.channel = this.channelValue;
+    this.ready = new Promise((resolve, reject) => {
+      this.resolveReady = resolve;
+      this.rejectReady = reject;
+    });
+    this.ready.catch(() => {});
+    this.events = new PixlEvents(this);
+    this.twitch = new PixlTwitch(this);
+    this.spotify = new PixlSpotify(this);
+    this.tts = new PixlTts2(this);
+    this.chat = new PixlChat2(this);
+    this.streamElements = new PixlStreamElements(this);
+    this.stream = this.demo ? null : new LiveStream({
+      url: `${this.baseUrl}/api/v1/stream?v=2`,
+      token: () => this.key,
+      fetch: this.fetchImpl,
+      onMessage: (m) => this.handleMessage(m),
+      onStatus: (s) => this.handleStatus(s),
+      log: (m) => this.log(m)
+    });
+    if (this.control) {
+      this.listenToDashboard(options.autoConnect !== false);
+      return;
+    }
+    if (options.autoConnect !== false)
+      queueMicrotask(() => this.connect());
+  }
+  widget() {
+    if (!this.widgetInstance && !this.warnedNoWidget && this.scopeList) {
+      this.warnedNoWidget = true;
+      console.warn("[pixl] widget() geht nur in gehosteten Widgets, nicht mit einem normalen API-Schlüssel");
+    }
+    return this.widgetInstance;
+  }
+  get scopes() {
+    return this.scopeList;
+  }
+  on(type, handler) {
+    let set = this.handlers.get(type);
+    if (!set)
+      this.handlers.set(type, set = new Set);
+    set.add(handler);
+    this.checkScope(type);
+    return () => {
+      set.delete(handler);
+    };
+  }
+  sendTestEvent(type, overrides = {}) {
+    const template = EVENT_TEMPLATES2[type];
+    const event = {
+      type,
+      data: { ...template, ...overrides },
+      at: new Date().toISOString(),
+      source: "test"
+    };
+    this.dispatch(event);
+    return event;
+  }
+  connect() {
+    if (this.demo) {
+      this.handleConnected({ type: "connected", protocol: 2, channel: DEMO_CHANNEL, scopes: ALL_SCOPES });
+      return;
+    }
+    this.stream?.start();
+  }
+  close() {
+    if (Pixl2.sharedInstance === this)
+      Pixl2.sharedInstance = null;
+    this.stream?.stop();
+    if (this.demo)
+      this.statusValue.set("closed");
+    this.handlers.clear();
+    this.internal.clear();
+    this.connectHandlers.clear();
+    this.twitch._close();
+    this.spotify._close();
+    this.channelValue.clear();
+    this.statusValue.clear();
+  }
+  async request(path, options = {}) {
+    const res = await this.fetchRaw(path, options);
+    return await res.json();
+  }
+  async fetchRaw(path, options = {}) {
+    if (this.demo)
+      throw new PixlError2("demo", "Im Demo-Modus gibt es keinen Server");
+    if (!this.key)
+      throw new PixlError2("unauthorized", "Noch kein Zugang (Steuer-Seite wartet auf das Dashboard)");
+    const url = new URL(`${this.baseUrl}/api/v1${path}`);
+    for (const [k, v] of Object.entries(options.query ?? {}))
+      if (v !== undefined && v !== "")
+        url.searchParams.set(k, String(v));
+    const headers = { Authorization: `Bearer ${this.key}` };
+    if (options.body !== undefined)
+      headers["Content-Type"] = "application/json";
+    else if (options.raw)
+      headers["Content-Type"] = options.raw.type || "application/octet-stream";
+    let res;
+    try {
+      res = await this.fetchImpl(url, {
+        method: options.method ?? "GET",
+        headers,
+        body: options.raw ?? (options.body !== undefined ? JSON.stringify(options.body) : undefined),
+        signal: options.signal
+      });
+    } catch (e) {
+      if (e instanceof DOMException && e.name === "AbortError")
+        throw e;
+      throw new PixlError2("network", "pixl ist gerade nicht erreichbar");
+    }
+    if (!res.ok)
+      throw await errorFromResponse(res);
+    return res;
+  }
+  _onConnect(fn) {
+    this.connectHandlers.add(fn);
+  }
+  _listen(type, handler) {
+    let set = this.internal.get(type);
+    if (!set)
+      this.internal.set(type, set = new Set);
+    set.add(handler);
+    return () => {
+      set.delete(handler);
+    };
+  }
+  widgetOptions() {
+    const preview = injected()?.preview === true;
+    return { preview, bind: !this.control || preview };
+  }
+  get _preview() {
+    return this.previewMode;
+  }
+  _log(message) {
+    this.log(message);
+  }
+  handleMessage(message) {
+    if (message.type === "connected") {
+      this.handleConnected(message);
+      return;
+    }
+    if (message.type === "access_revoked")
+      return;
+    if (message.type.startsWith("widget.")) {
+      this.handleWidgetMessage(message);
+      return;
+    }
+    this.dispatch(message);
+  }
+  handleWidgetMessage(message) {
+    if (message.type === "widget.version") {
+      if (!this.control && injected()?.widget && typeof location !== "undefined")
+        location.reload();
+      return;
+    }
+    this.widgetInstance?._handle(message);
+  }
+  listenToDashboard(autoConnect) {
+    if (typeof window === "undefined" || window.parent === window) {
+      this.log("Steuer-Seite außerhalb des Dashboards geöffnet, kein Zugang");
+      return;
+    }
+    window.addEventListener("message", (e) => {
+      if (e.source !== window.parent || typeof e.data !== "object" || !e.data)
+        return;
+      if (e.data.type === "pixl:control" && typeof e.data.token === "string") {
+        const first = !this.key;
+        this.key = e.data.token;
+        if (first && autoConnect)
+          this.connect();
+      }
+    });
+    startFrameBridge();
+    window.parent.postMessage({ type: "pixl:ready" }, "*");
+  }
+  handleConnected(hello) {
+    this.scopeList = hello.scopes;
+    this.channelValue.set(hello.channel);
+    if (hello.widget) {
+      if (this.widgetInstance)
+        this.widgetInstance._setState(hello.widget);
+      else
+        this.widgetInstance = new PixlWidget2(this, hello.widget, this.widgetOptions());
+    }
+    this.statusValue.set("connected");
+    for (const type of this.handlers.keys())
+      this.checkScope(type);
+    const loads = [...this.connectHandlers].map((fn) => Promise.resolve().then(fn));
+    Promise.allSettled(loads).then(() => {
+      if (this.readySettled)
+        return;
+      this.readySettled = true;
+      this.resolveReady();
+    });
+  }
+  handleStatus(status) {
+    if (status === "connected")
+      return;
+    this.statusValue.set(status);
+    if (status === "unauthorized" && !this.readySettled) {
+      this.readySettled = true;
+      this.rejectReady(new PixlError2("unauthorized", "Zugang ungültig oder widerrufen"));
+    }
+  }
+  dispatch(event) {
+    for (const h of [...this.internal.get(event.type) ?? []])
+      safeCall(() => h(event));
+    for (const h of [...this.handlers.get(event.type) ?? []])
+      safeCall(() => h(event));
+    for (const h of [...this.handlers.get("*") ?? []])
+      safeCall(() => h(event));
+  }
+  checkScope(type) {
+    if (!this.scopeList || type === "*")
+      return;
+    const scope = apiScopeForEvent(type);
+    if (!scope || this.scopeList.includes(scope) || this.warnedScopes.has(scope))
+      return;
+    this.warnedScopes.add(scope);
+    console.warn(`[pixl] "${type}" kommt nie an: dem Schlüssel fehlt die Erlaubnis ${scope}`);
+  }
+  log(message) {
+    if (this.logs)
+      console.info(`[pixl] ${message}`);
+  }
+}
+
+export { EVENT_TEMPLATES2, emoteUrl2, escapeHtml2, chatHtml2, badgesHtml2, CHAT_CSS2, paintCss2, PixlChat2, PixlError2, EventFeed2, FONT_HOST2, fontStylesheetUrl2, fontFamily2, loadFont2, PixlTts2, TtsPlayer2, PixlWidget2, Pixl2 };