@lumencast/runtime 0.9.0 → 0.10.0

package/dist/index-Clrya_9l.js

@@ -0,0 +1,1281 @@
+import { batch as T, signal as v } from "@preact/signals-react";
+import { createRoot as q } from "react-dom/client";
+import { createContext as te, useContext as W, lazy as E, Suspense as se, createElement as ne, StrictMode as re } from "react";
+import { jsx as m } from "react/jsx-runtime";
+import { useSignals as ie } from "@preact/signals-react/runtime";
+import { AnimatePresence as oe, motion as ae } from "framer-motion";
+import { SequenceTracker as ce, encodeFrame as O, input as le, WS_SUBPROTOCOLS as ue, WS_SUBPROTOCOL_V1_1 as de, subscribe as he, decodeServerFrame as fe, LumencastError as L } from "@lumencast/protocol";
+const I = te(null);
+function z({
+  value: t,
+  children: e
+}) {
+  return /* @__PURE__ */ m(I.Provider, { value: t, children: e });
+}
+function at() {
+  const t = W(I);
+  if (!t)
+    throw new Error(
+      "Lumencast overlay components must be rendered inside LumencastRuntimeProvider"
+    );
+  return t;
+}
+function ct() {
+  return W(I);
+}
+const me = E(
+  () => import("./broadcast-L5wm2I6J.js").then((t) => ({ default: t.BroadcastMode }))
+), pe = E(
+  () => import("./control-eEUG7unp.js").then((t) => ({ default: t.ControlMode }))
+), ge = E(() => import("./test-7q_KJkdX.js").then((t) => ({ default: t.TestMode })));
+function ve({
+  mode: t,
+  store: e,
+  bundleSignal: s,
+  statusSignal: n,
+  crossfadeKeySignal: r,
+  sendInput: o,
+  resolveCaptureDevice: a,
+  resolvePeerStream: i,
+  subscribePeerStream: l
+}) {
+  ie();
+  const c = s.value, d = n.value, h = r.value;
+  if (!c) return null;
+  const w = t === "broadcast" ? me : t === "control" ? pe : ge;
+  return /* @__PURE__ */ m(oe, { mode: "sync", children: /* @__PURE__ */ m(
+    ae.div,
+    {
+      initial: { opacity: 0 },
+      animate: { opacity: 1 },
+      exit: { opacity: 0 },
+      transition: { duration: 0.4, ease: "easeInOut" },
+      style: { position: "absolute", inset: 0 },
+      children: /* @__PURE__ */ m(
+        z,
+        {
+          value: {
+            mode: t,
+            store: e,
+            bundle: c,
+            status: d,
+            sendInput: o,
+            ...a !== void 0 ? { resolveCaptureDevice: a } : {},
+            ...i !== void 0 ? { resolvePeerStream: i } : {},
+            ...l !== void 0 ? { subscribePeerStream: l } : {}
+          },
+          children: /* @__PURE__ */ m(se, { fallback: null, children: /* @__PURE__ */ m(w, {}) })
+        }
+      )
+    },
+    h
+  ) });
+}
+const we = "<anon>", b = /* @__PURE__ */ new Set();
+function B(t) {
+  return b.add(t), () => {
+    b.delete(t);
+  };
+}
+function H(t, e, s) {
+  const n = { nodeId: t ?? we, field: e, reason: s };
+  if (b.size > 0) {
+    for (const r of b)
+      try {
+        r(n);
+      } catch {
+      }
+    return;
+  }
+}
+const ye = 100, be = 4, ke = 64, Se = {
+  blur: ye,
+  brightness: be
+};
+function M(t, e) {
+  if (typeof e != "number" || !Number.isFinite(e) || e < 0 || Object.is(e, -0)) return null;
+  const s = Se[t];
+  return e > s ? s : e;
+}
+const Te = /^blur\((\d{1,7}(?:\.\d{1,4})?)px\) brightness\((\d{1,7}(?:\.\d{1,4})?)\)$/, lt = "blur(0px) brightness(1)";
+function Ee(t) {
+  if (typeof t != "string" || t.length === 0 || t.length > ke) return null;
+  const e = Te.exec(t);
+  if (!e) return null;
+  const s = M("blur", Number(e[1])), n = M("brightness", Number(e[2]));
+  return s === null || n === null ? null : `blur(${s}px) brightness(${n})`;
+}
+function Ie(t, e) {
+  H(
+    e,
+    t,
+    "rejected unsafe filter value : outside the R8 caps or not a finite number >= 0"
+  );
+}
+const _e = { duration: 0 }, Re = {
+  linear: "linear",
+  "cubic-in": "easeIn",
+  "cubic-out": "easeOut",
+  "cubic-in-out": "easeInOut"
+};
+function ut(t) {
+  return !t || t.kind === "none" ? _e : t.kind === "tween" ? {
+    type: "tween",
+    duration: (t.duration_ms ?? 0) / 1e3,
+    ease: t.ease ? Re[t.ease] ?? "easeOut" : "easeOut"
+  } : t.kind === "spring" ? {
+    type: "spring",
+    ...t.stiffness !== void 0 ? { stiffness: t.stiffness } : {},
+    ...t.damping !== void 0 ? { damping: t.damping } : {},
+    ...t.mass !== void 0 ? { mass: t.mass } : {}
+  } : {
+    type: "tween",
+    duration: (t.duration_ms ?? 400) / 1e3,
+    ease: "easeInOut"
+  };
+}
+const Ae = {
+  opacity: 1,
+  scale: 1,
+  scaleX: 1,
+  scaleY: 1,
+  rotate: 0,
+  x: 0,
+  y: 0,
+  // LSML §6.1 filter identity — both functions are always present so
+  // framer interpolates between structurally-identical filter lists
+  // (the compiler emits the same two-function form, clamped per R8).
+  filter: "blur(0px) brightness(1)"
+}, Pe = {
+  kind: "tween",
+  duration_ms: 400,
+  ease: "cubic-out"
+};
+function dt(t, e, s) {
+  for (const n of e) {
+    const r = t(n);
+    if (r !== void 0) return r;
+  }
+  if (s && Object.keys(s).length > 0) {
+    for (const n of Object.keys(s)) {
+      const r = t(n);
+      if (r !== void 0) return r;
+    }
+    return Pe;
+  }
+}
+function ht(t, e, s) {
+  if (!e || Object.keys(e).length === 0)
+    return { initial: t, animate: t };
+  let n = e;
+  if (e.filter !== void 0) {
+    const o = Ee(e.filter);
+    n = { ...e }, o === null ? (Ie("animate_initial.filter", s), delete n.filter) : n.filter = o;
+  }
+  const r = { ...t };
+  for (const o of Object.keys(n))
+    o in r || (r[o] = Ae[o] ?? 0);
+  return { initial: n, animate: r };
+}
+function Oe(t) {
+  if (typeof t != "object" || t === null) return;
+  const e = t, s = e.kind;
+  if (s === "snap")
+    return { kind: "none" };
+  if (s === "tween") {
+    const n = typeof e.duration_ms == "number" ? e.duration_ms : 0, r = Le[e.easing] ?? "cubic-out";
+    return { kind: "tween", duration_ms: n, ease: r };
+  }
+  if (s === "spring") {
+    const n = { kind: "spring" };
+    return typeof e.stiffness == "number" && (n.stiffness = e.stiffness), typeof e.damping == "number" && (n.damping = e.damping), typeof e.mass == "number" && (n.mass = e.mass), n;
+  }
+}
+const Le = {
+  linear: "linear",
+  "ease-in": "cubic-in",
+  "ease-out": "cubic-out",
+  "ease-in-out": "cubic-in-out"
+};
+function Me(t, e) {
+  T(() => {
+    for (const s of e.patches) {
+      const n = Oe(s.transition);
+      n !== void 0 ? t.setWithTransition(s.path, s.value, n) : t.set(s.path, s.value);
+    }
+  });
+}
+function Ce(t, e) {
+  t.reset(e.state);
+}
+class Ne {
+  signals = /* @__PURE__ */ new Map();
+  transitions = /* @__PURE__ */ new Map();
+  signal(e) {
+    let s = this.signals.get(e);
+    return s || (s = v(void 0), this.signals.set(e, s)), s;
+  }
+  transitionSignal(e) {
+    let s = this.transitions.get(e);
+    return s || (s = v(void 0), this.transitions.set(e, s)), s;
+  }
+  set(e, s) {
+    const n = this.signal(e);
+    S(n.peek(), s) || (n.value = s);
+  }
+  setWithTransition(e, s, n) {
+    T(() => {
+      const r = this.transitionSignal(e);
+      r.peek() !== n && (r.value = n);
+      const o = this.signal(e);
+      S(o.peek(), s) || (o.value = s);
+    });
+  }
+  reset(e) {
+    T(() => {
+      const s = /* @__PURE__ */ new Set();
+      for (const [n, r] of Object.entries(e)) {
+        s.add(n);
+        const o = this.signal(n);
+        S(o.peek(), r) || (o.value = r);
+        const a = this.transitions.get(n);
+        a && a.peek() !== void 0 && (a.value = void 0);
+      }
+      for (const n of this.signals.keys())
+        if (!s.has(n)) {
+          const r = this.signals.get(n);
+          r && r.peek() !== void 0 && (r.value = void 0);
+        }
+    });
+  }
+  toRecord() {
+    const e = {};
+    for (const [s, n] of this.signals.entries())
+      e[s] = n.peek();
+    return e;
+  }
+}
+function G() {
+  return new Ne();
+}
+function S(t, e) {
+  if (t === e) return !0;
+  if (t === null || e === null || typeof t != typeof e || typeof t != "object" || Array.isArray(t) !== Array.isArray(e)) return !1;
+  if (Array.isArray(t) && Array.isArray(e)) {
+    if (t.length !== e.length) return !1;
+    for (let a = 0; a < t.length; a++)
+      if (t[a] !== e[a]) return !1;
+    return !0;
+  }
+  const s = t, n = e, r = Object.keys(s), o = Object.keys(n);
+  if (r.length !== o.length) return !1;
+  for (const a of r)
+    if (s[a] !== n[a]) return !1;
+  return !0;
+}
+const xe = /* @__PURE__ */ new Set([
+  "x-lumencast.color-srgb-1.0",
+  // RFC-0001 / ADR 004 — this runtime ships the Zab capture plugin, so a
+  // bundle declaring `x-zab.capture/1` in `profiles[]` is compatible (it is
+  // NOT rejected as BUNDLE_INCOMPATIBLE, §17.3.1).
+  "x-zab.capture/1"
+]), je = /^x-[a-z0-9-]+(?:\.[a-z0-9-]+)*$/, De = /^(?:0|[1-9][0-9]*)$/, C = ".authoring";
+function Ue(t) {
+  const e = t.indexOf("/");
+  if (e < 0) return !1;
+  const s = t.slice(0, e), n = t.slice(e + 1);
+  return !De.test(n) || !s.endsWith(C) ? !1 : je.test(s.slice(0, -C.length));
+}
+class N extends Error {
+  code = "BUNDLE_INCOMPATIBLE";
+  unsupportedProfiles;
+  constructor(e) {
+    super(
+      `BUNDLE_INCOMPATIBLE: profile(s) not supported by this runtime: ${e.join(
+        ", "
+      )}`
+    ), this.name = "BundleIncompatibleError", this.unsupportedProfiles = e;
+  }
+}
+function x(t, e = xe) {
+  const s = t.profiles;
+  if (!s) return;
+  if (!Array.isArray(s))
+    throw new N(["<malformed: profiles is not an array>"]);
+  if (s.length === 0) return;
+  const n = s.filter((r) => typeof r != "string" || !Ue(r) && !e.has(r)).map((r) => typeof r == "string" ? r : "<malformed: non-string profile entry>");
+  if (n.length > 0)
+    throw new N(n);
+}
+class $e {
+  cache = /* @__PURE__ */ new Map();
+  baseUrl;
+  pathPrefix;
+  resolveUrl;
+  getAuthToken;
+  fetchImpl;
+  constructor(e) {
+    this.baseUrl = e.baseUrl.replace(/\/$/, ""), this.pathPrefix = (e.pathPrefix ?? "/lsdp/v1/scenes").replace(/\/$/, ""), this.resolveUrl = e.resolveUrl, this.getAuthToken = e.getAuthToken, this.fetchImpl = e.fetchImpl ?? globalThis.fetch.bind(globalThis);
+  }
+  /** Build the request init carrying the bearer token, if any. Returns
+   *  `undefined` when no token is available — the fetch stays header-less,
+   *  preserving v0.5.0 behaviour. */
+  async buildInit() {
+    if (!this.getAuthToken) return;
+    const e = await this.getAuthToken();
+    if (e)
+      return { headers: { Authorization: `Bearer ${e}` } };
+  }
+  buildUrl(e, s) {
+    return this.resolveUrl ? this.resolveUrl(e, s) : `${this.baseUrl}${this.pathPrefix}/${encodeURIComponent(e)}/bundle?v=${encodeURIComponent(s)}`;
+  }
+  preload(e) {
+    x(e), this.cache.set(e.scene_version, e);
+  }
+  async get(e, s) {
+    const n = this.cache.get(s);
+    if (n) return n;
+    const r = this.buildUrl(e, s), o = await this.buildInit(), a = o ? await this.fetchImpl(r, o) : await this.fetchImpl(r);
+    if (!a.ok)
+      throw new Error(`bundle fetch failed: ${a.status} ${a.statusText}`);
+    const i = await a.json();
+    if (i.scene_version !== s)
+      throw new Error(
+        `bundle scene_version mismatch: expected ${s}, got ${i.scene_version}`
+      );
+    return x(i), this.cache.set(s, i), i;
+  }
+}
+function Fe(t) {
+  return new $e(t);
+}
+const y = {
+  initial: 200,
+  max: 5e3,
+  factor: 2,
+  jitter: 0.2
+};
+class qe {
+  constructor(e, s) {
+    this.opts = e, this.random = s;
+  }
+  _attempt = 0;
+  get attempt() {
+    return this._attempt;
+  }
+  delayFor(e) {
+    if (!Number.isInteger(e) || e < 1)
+      throw new RangeError(`attempt must be a positive integer, got ${e}`);
+    this._attempt = e;
+    const s = Math.min(
+      this.opts.initial * Math.pow(this.opts.factor, e - 1),
+      this.opts.max
+    );
+    if (this.opts.jitter <= 0) return s;
+    const n = (this.random() * 2 - 1) * this.opts.jitter * s;
+    return Math.max(0, s + n);
+  }
+  reset() {
+    this._attempt = 0;
+  }
+}
+function We(t = {}) {
+  const e = {
+    initial: t.initial ?? y.initial,
+    max: t.max ?? y.max,
+    factor: t.factor ?? y.factor,
+    jitter: t.jitter ?? y.jitter
+  };
+  if (e.initial <= 0) throw new RangeError("initial must be > 0");
+  if (e.max < e.initial) throw new RangeError("max must be >= initial");
+  if (e.factor < 1) throw new RangeError("factor must be >= 1");
+  if (e.jitter < 0 || e.jitter > 1) throw new RangeError("jitter must be within [0, 1]");
+  return new qe(e, t.random ?? Math.random);
+}
+class p extends Error {
+  recoverable;
+  code;
+  cause;
+  constructor(e, s, n = "INTERNAL", r) {
+    super(e), this.name = "TransportError", this.recoverable = s, this.code = n, this.cause = r;
+  }
+}
+class ze {
+  status = "disconnected";
+  socket = null;
+  token;
+  url;
+  WebSocketCtor;
+  schedule;
+  seq = new ce();
+  opts;
+  scheduler;
+  reconnectTimer = null;
+  active = !0;
+  constructor(e) {
+    this.opts = e, this.url = e.url, this.token = e.token;
+    const s = e.webSocketImpl ?? globalThis.WebSocket;
+    if (!s)
+      throw new TypeError(
+        "Lumencast WsClient: no WebSocket implementation found in this environment"
+      );
+    this.WebSocketCtor = s, this.schedule = We(e.reconnect), this.scheduler = e.scheduler ?? {
+      setTimeout: globalThis.setTimeout.bind(globalThis),
+      clearTimeout: globalThis.clearTimeout.bind(globalThis)
+    };
+  }
+  /** Open and start the connection lifecycle. Idempotent. */
+  start() {
+    this.active && (this.socket || this.status === "connecting" || this.openSocket());
+  }
+  /** Resolve the current session token (the one used for the WS
+   *  subscription). Mirrors `setToken` swaps. Used by the bundle fetcher to
+   *  authenticate the render-bundle GET with the same credential. A
+   *  `LumencastTokenProvider` is awaited. */
+  resolveCurrentToken() {
+    return j(this.token);
+  }
+  /** Send `input` patches to the server. No-op if not connected. */
+  sendInput(e) {
+    !this.socket || this.socket.readyState !== this.WebSocketCtor.OPEN || e.length !== 0 && this.socket.send(O(le(e)));
+  }
+  /** Replace the auth token. Closes and reopens with the new token. */
+  setToken(e) {
+    this.token = e, this.active && this.socket && (this.closeSocket(), this.scheduleReconnect(!0));
+  }
+  /** Tear down for good. No more reconnect attempts. */
+  close() {
+    this.active && (this.active = !1, this.cancelReconnect(), this.closeSocket(), this.setStatus("disconnected"));
+  }
+  // --- internals --------------------------------------------------
+  async openSocket() {
+    if (!this.active) return;
+    this.setStatus("connecting");
+    let e;
+    try {
+      e = await j(this.token);
+    } catch (n) {
+      this.opts.onTransportError?.(
+        new p(
+          `failed to resolve token: ${n.message}`,
+          !0,
+          "AUTH_DENIED",
+          n
+        )
+      ), this.scheduleReconnect();
+      return;
+    }
+    if (!this.active) return;
+    let s;
+    try {
+      s = new this.WebSocketCtor(this.url, [...ue]);
+    } catch (n) {
+      this.opts.onTransportError?.(
+        new p(
+          `failed to open WebSocket: ${n.message}`,
+          !0,
+          "INTERNAL",
+          n
+        )
+      ), this.scheduleReconnect();
+      return;
+    }
+    this.socket = s, s.onopen = () => this.handleOpen(e), s.onmessage = (n) => this.handleMessage(n), s.onerror = (n) => this.handleError(n), s.onclose = (n) => this.handleClose(n);
+  }
+  handleOpen(e) {
+    if (!this.socket) return;
+    const n = this.socket.protocol === de && this.seq.last > 0, r = n ? this.seq.last : void 0;
+    n || this.seq.reset();
+    const o = he({
+      token: e,
+      ...this.opts.scene !== void 0 ? { scene: this.opts.scene } : {},
+      ...this.opts.session !== void 0 ? { session: this.opts.session } : {},
+      ...r !== void 0 ? { since_sequence: r } : {}
+    });
+    this.socket.send(O(o));
+  }
+  handleMessage(e) {
+    const s = typeof e.data == "string" ? e.data : "";
+    if (!s) return;
+    let n;
+    try {
+      n = fe(s);
+    } catch (r) {
+      const o = (r instanceof L, r.message), a = r instanceof L ? r.code : "INTERNAL";
+      this.opts.onTransportError?.(new p(`codec: ${o}`, !0, a, r)), this.closeSocket(), this.scheduleReconnect();
+      return;
+    }
+    if (n !== null)
+      switch (n.type) {
+        case "snapshot": {
+          if (n.seq < 1) {
+            this.opts.onTransportError?.(
+              new p(`snapshot seq must be >= 1, got ${n.seq}`, !0, "VERSION_GAP")
+            ), this.closeSocket(), this.scheduleReconnect();
+            return;
+          }
+          this.seq.observeSnapshot(n.seq), this.schedule.reset(), this.setStatus("live"), this.opts.onSnapshot?.(n);
+          return;
+        }
+        case "delta": {
+          const r = this.seq.observe(n.seq);
+          if (r.kind === "gap") {
+            this.opts.onTransportError?.(
+              new p(
+                `sequence gap: expected ${this.seq.last + 1}, got ${n.seq}`,
+                !0,
+                "VERSION_GAP"
+              )
+            ), this.closeSocket(), this.scheduleReconnect();
+            return;
+          }
+          if (r.kind === "duplicate") return;
+          this.opts.onDelta?.(n);
+          return;
+        }
+        case "scene_changed": {
+          this.seq.reset(), this.opts.onSceneChanged?.(n);
+          return;
+        }
+        case "error": {
+          this.opts.onServerError?.(n), n.recoverable || this.close();
+          return;
+        }
+        case "pong":
+          return;
+      }
+  }
+  handleError(e) {
+  }
+  handleClose(e) {
+    if (this.socket = null, !this.active) {
+      this.setStatus("disconnected");
+      return;
+    }
+    if (e.code === 4401 || e.code === 4403 || e.code === 1008) {
+      this.opts.onTransportError?.(
+        new p(`server closed: ${e.code} ${e.reason}`, !1, "AUTH_DENIED")
+      ), this.close();
+      return;
+    }
+    this.scheduleReconnect();
+  }
+  scheduleReconnect(e = !1) {
+    if (!this.active) return;
+    this.cancelReconnect();
+    const s = (this.schedule.attempt || 0) + 1, n = e ? 0 : this.schedule.delayFor(s);
+    this.setStatus("disconnected"), this.reconnectTimer = this.scheduler.setTimeout(() => {
+      this.reconnectTimer = null, this.openSocket();
+    }, n);
+  }
+  cancelReconnect() {
+    this.reconnectTimer && (this.scheduler.clearTimeout(this.reconnectTimer), this.reconnectTimer = null);
+  }
+  closeSocket() {
+    if (this.socket) {
+      try {
+        this.socket.close(1e3, "client closing");
+      } catch {
+      }
+      this.socket = null;
+    }
+  }
+  setStatus(e) {
+    this.status !== e && (this.status = e, this.opts.onStatus?.(e));
+  }
+}
+async function j(t) {
+  return typeof t == "string" ? t : await t.fetch();
+}
+function Be(t) {
+  if (!(t.target instanceof HTMLElement))
+    throw new TypeError("mount: `target` must be an HTMLElement");
+  if (typeof t.serverUrl != "string" || t.serverUrl.length === 0)
+    throw new TypeError("mount: `serverUrl` must be a non-empty string");
+  if (t.mode === "test") {
+    if (!t.testSession)
+      throw new TypeError("mount: `testSession` is required when mode === 'test'");
+    if (!t.scene)
+      throw new TypeError("mount: `scene` is required when mode === 'test'");
+  }
+}
+function ft(t) {
+  Be(t), t.onStatus?.("disconnected");
+  const e = G(), s = Ge(t.serverUrl), n = Fe({
+    baseUrl: s,
+    ...t.resolveBundleUrl !== void 0 ? { resolveUrl: t.resolveBundleUrl } : {},
+    getAuthToken: () => h.resolveCurrentToken()
+  }), r = v(null), o = v("disconnected"), a = v("__initial__"), i = (u) => {
+    o.value = u, t.onStatus?.(u);
+  }, l = (u) => {
+    t.onError?.(u);
+  };
+  let c = !0;
+  const d = t.onDiagnostic ? B(t.onDiagnostic) : void 0, h = new ze({
+    url: t.serverUrl,
+    token: t.token,
+    ...t.scene !== void 0 ? { scene: t.scene } : {},
+    ...t.testSession !== void 0 ? { session: t.testSession } : {},
+    onStatus: i,
+    onSnapshot: (u) => {
+      c && (J(
+        n,
+        r,
+        a,
+        u.scene_id,
+        u.scene_version,
+        () => Ce(e, u),
+        l
+      ), t.onMetric?.({
+        name: "snapshot_received",
+        scene_id: u.scene_id,
+        path_count: Object.keys(u.state).length
+      }));
+    },
+    onDelta: (u) => {
+      if (!c) return;
+      const k = performance.now();
+      Me(e, u), t.onMetric?.({
+        name: "delta_applied",
+        duration_ms: performance.now() - k
+      }), t.onMetric?.({ name: "delta_received", count: 1, path_count: u.patches.length });
+    },
+    onSceneChanged: (u) => {
+      c && t.onMetric?.({
+        name: "scene_changed",
+        from: r.value?.scene_version ?? null,
+        to: u.scene_version
+      });
+    },
+    onServerError: (u) => {
+      l({
+        code: u.code,
+        message: u.message,
+        recoverable: u.recoverable
+      });
+    },
+    onTransportError: (u) => {
+      l(He(u));
+    }
+  });
+  h.start();
+  const w = q(t.target);
+  return w.render(
+    ne(ve, {
+      mode: t.mode,
+      store: e,
+      bundleSignal: r,
+      statusSignal: o,
+      crossfadeKeySignal: a,
+      sendInput: (u) => h.sendInput(u),
+      // ADR 004 §A1.3 — thread the host capture resolver to the runtime context
+      // so the `x-zab.capture` primitive's ACQUIRE mode can pin a device.
+      ...t.resolveCaptureDevice !== void 0 ? { resolveCaptureDevice: t.resolveCaptureDevice } : {},
+      // ADR 006 #4 — thread the host peer-stream resolver (supplied by the
+      // WebRTC viewer #3) so the `media` primitive's LIVE mode can render a
+      // peer's MediaStream in `srcObject`.
+      ...t.resolvePeerStream !== void 0 ? { resolvePeerStream: t.resolvePeerStream } : {},
+      // ADR 006 #3 — reactive variant : the LIVE `media` node re-renders when a
+      // peer connects/leaves mid-show. `createPeerViewer()` supplies it.
+      ...t.subscribePeerStream !== void 0 ? { subscribePeerStream: t.subscribePeerStream } : {}
+    })
+  ), {
+    disconnect() {
+      c && (c = !1, d?.(), h.close(), w.unmount());
+    },
+    setToken(u) {
+      c && h.setToken(u);
+    }
+  };
+  async function J(u, k, Z, _, R, Q, ee) {
+    let A;
+    try {
+      A = await u.get(_, R);
+    } catch (P) {
+      ee({
+        code: "BUNDLE_FETCH_FAILED",
+        message: P instanceof Error ? P.message : "render bundle fetch failed",
+        recoverable: !0
+      });
+      return;
+    }
+    c && (Q(), k.value = A, Z.value = `${_}::${R}`);
+  }
+}
+function He(t) {
+  return {
+    code: t.code,
+    message: t.message,
+    recoverable: t.recoverable
+  };
+}
+function Ge(t) {
+  try {
+    const e = new URL(t);
+    return `${e.protocol === "wss:" ? "https:" : "http:"}//${e.host}`;
+  } catch {
+    return "";
+  }
+}
+const Ke = [
+  "visible",
+  "opacity",
+  "universal_opacity",
+  "rotation",
+  "sizing",
+  "x",
+  "y",
+  "width",
+  "height",
+  // ADR 002 §3.2 (D2 / #D) — `blendMode` is consumed universally by the
+  // wrapper (→ CSS `mix-blend-mode`) on every primitive.
+  "blendMode",
+  // ADR 002 §3.2 (#E) — a typed `mask` is lowered onto EVERY primitive by the
+  // compiler and consumed by the Tree (built into a `<mask>` SVG element).
+  "mask"
+];
+function f(t) {
+  return /* @__PURE__ */ new Set([...Ke, ...t]);
+}
+const Xe = {
+  stack: f(["direction", "gap", "wrap", "crossGap", "align", "justify"]),
+  grid: f(["cols", "rows", "gap"]),
+  frame: f([
+    "x",
+    "y",
+    "width",
+    "height",
+    "scale",
+    "rotate",
+    "background",
+    "backgrounds",
+    "clipsContent"
+  ]),
+  text: f([
+    "value",
+    "size",
+    "font",
+    "weight",
+    "colour",
+    "align",
+    "lineHeight",
+    "letterSpacing",
+    "textTransform",
+    "textDecoration",
+    "fontStyle",
+    "maxLines"
+  ]),
+  image: f(["src", "alt", "fit", "position", "width", "height"]),
+  shape: f([
+    "geometry",
+    "kind",
+    "width",
+    "height",
+    "radius",
+    "fill",
+    "fills",
+    "stroke",
+    "stroke_width",
+    "strokes",
+    "pathData",
+    "paths",
+    "ariaLabel"
+  ]),
+  // `peerLabel` (ADR 006 #4) selects the live MediaStream mode : a node whose
+  // source is a `meet.peer.peer_label` is rendered in `srcObject` from a host
+  // resolver instead of `<video src>`. Listed so it is NOT flagged as a silent
+  // drop by the anti-drop audit when a scene carries a live source.
+  media: f(["src", "peerLabel", "loop", "mute", "autoplay", "fit"]),
+  // ADR 006 §3.3/§3.5 — the unified source kind. `peer_label` is the stream
+  // reference (resolved to a MediaStream → srcObject) ; `object_fit`/`muted`
+  // drive the video ; `x-zab.sourceKind` is advisory ; `metadata` carries the
+  // editor round-trip (figma). Geometry is universal as flat `x/y/width/height`,
+  // but an UNCOMPILED from-scene node carries the NESTED `position`/`size` shape
+  // (the Tree flattens it as a fallback) — listed so neither form is flagged as
+  // a silent drop by the anti-drop audit.
+  "meet.peer": f([
+    "peer_label",
+    "object_fit",
+    "muted",
+    "x-zab.sourceKind",
+    "metadata",
+    "position",
+    "size"
+  ]),
+  instance: f(["scene_id", "scene_version", "size", "position"]),
+  // RFC-0001 / ADR 004 — vendor capture placeholder. `width`/`height` are the
+  // flattened geometry (universal) ; the `x-zab.*` props are carried as
+  // metadata (the renderer reserves the box, ignores deviceRef). Listed so
+  // they are NOT flagged as silent drops by the anti-drop audit.
+  "x-zab.capture": f(["x-zab.sourceKind", "x-zab.deviceRef", "width", "height"]),
+  // ADR Blue 009 §3.1 (Amendment 2) — vendor meet-peer SLOT placeholder.
+  // `width`/`height` are the flattened geometry (universal) ; `x-zab.slotRef`
+  // is the logical slot identity carried as metadata (the runtime resolves
+  // `slotRef → peer_label` from stream-level ZabCam state). NO cam/peer
+  // identity is carried. Listed so they are NOT flagged as silent drops.
+  "x-zab.meet-peer": f(["x-zab.slotRef", "width", "height"]),
+  // `repeat` is dispatched specially by the tree ; its only consumed
+  // binding is `items`.
+  repeat: /* @__PURE__ */ new Set(["items"])
+};
+function Ve(t, e) {
+  const s = Xe[t];
+  return !!(s === void 0 || s.has(e) || t === "instance" && (e === "params" || e.startsWith("params.")));
+}
+const D = /* @__PURE__ */ new WeakSet();
+function mt(t) {
+  if (D.has(t)) return;
+  D.add(t);
+  const e = /* @__PURE__ */ new Set([
+    ...Object.keys(t.props ?? {}),
+    ...Object.keys(t.bindings ?? {})
+  ]);
+  for (const s of e)
+    Ve(t.kind, s) || H(
+      t.id,
+      `${t.kind}.${s}`,
+      "is not consumed by this primitive's renderer ; the prop is ignored (anti-silent-drop, ADR 001 §3.4)"
+    );
+}
+class K {
+  constructor(e) {
+    this.options = e, this.deps = {
+      WebSocket: e.deps?.WebSocket ?? globalThis.WebSocket,
+      RTCPeerConnection: e.deps?.RTCPeerConnection ?? globalThis.RTCPeerConnection,
+      MediaStream: e.deps?.MediaStream ?? globalThis.MediaStream
+    };
+  }
+  ws = null;
+  remotes = /* @__PURE__ */ new Map();
+  iceServers = [];
+  selfId = null;
+  listeners = /* @__PURE__ */ new Map();
+  deps;
+  on(e, s) {
+    const n = this.listeners.get(e) ?? /* @__PURE__ */ new Set();
+    return this.listeners.set(e, n), n.add(s), () => n.delete(s);
+  }
+  /** Join the room as a VIEWER (recvonly). No capture, no publish. */
+  join() {
+    return this.openSocket();
+  }
+  /** Leave and tear down every peer connection + aggregated stream. As the
+   *  track owner, this is where the streams (and the device-side tracks) end. */
+  leave() {
+    this.send({ type: "leave" }), this.ws?.close(1e3, "viewer-leave");
+  }
+  /* ---- Socket ------------------------------------------------------- */
+  openSocket() {
+    const e = new URL(this.options.signalingUrl);
+    return e.searchParams.set("room", this.options.roomId), e.searchParams.set("token", this.options.token), new Promise((s, n) => {
+      const r = new this.deps.WebSocket(e.toString());
+      this.ws = r;
+      const o = () => {
+        r.removeEventListener("error", a), this.send({ type: "join", name: this.options.name, role: "viewer" }), s();
+      }, a = (i) => {
+        r.removeEventListener("open", o), n(i);
+      };
+      r.addEventListener("open", o, { once: !0 }), r.addEventListener("error", a, { once: !0 }), r.addEventListener("message", (i) => void this.onMessage(i.data)), r.addEventListener("close", (i) => {
+        this.tearDown(), this.emit("close", { code: i.code, reason: i.reason });
+      });
+    });
+  }
+  send(e) {
+    this.ws && this.ws.readyState === this.deps.WebSocket.OPEN && this.ws.send(JSON.stringify(e));
+  }
+  tearDown() {
+    for (const e of this.remotes.values()) e.pc.close();
+    this.remotes.clear();
+  }
+  /* ---- Protocol ----------------------------------------------------- */
+  async onMessage(e) {
+    let s;
+    try {
+      s = JSON.parse(String(e));
+    } catch {
+      return;
+    }
+    switch (s.type) {
+      case "joined": {
+        this.selfId = s.peerId, this.iceServers = s.turn.urls.map((n) => ({
+          urls: n,
+          username: s.turn.username,
+          credential: s.turn.credential
+        })), this.emit("joined", { peerId: s.peerId, peers: s.peers });
+        for (const n of s.peers) this.ensureRemote(n);
+        break;
+      }
+      case "peer-joined": {
+        this.emit("peer-joined", s.peer), this.ensureRemote(s.peer);
+        break;
+      }
+      case "peer-left": {
+        const n = this.remotes.get(s.peerId);
+        n && (n.pc.close(), this.remotes.delete(s.peerId), this.emit("peer-left", { peerId: s.peerId, peerName: n.info.name }));
+        break;
+      }
+      case "signal": {
+        await this.handleSignal(s.from, s.payload);
+        break;
+      }
+      case "error": {
+        this.emit("error", { code: s.code, message: s.message });
+        break;
+      }
+    }
+  }
+  async handleSignal(e, s) {
+    let n = this.remotes.get(e);
+    n || (n = this.ensureRemote({ id: e, name: e.slice(0, 8), role: "publisher" }));
+    const { pc: r } = n;
+    if (s.kind === "sdp") {
+      const o = s.description, a = o.type === "offer" && (n.makingOffer || r.signalingState !== "stable");
+      if (n.ignoreOffer = !this.isPolite(e) && a, n.ignoreOffer) return;
+      await r.setRemoteDescription(o);
+      for (const i of n.pendingCandidates)
+        try {
+          await r.addIceCandidate(i);
+        } catch {
+        }
+      n.pendingCandidates = [], o.type === "offer" && (await r.setLocalDescription(), r.localDescription && this.sendSignal(e, {
+        kind: "sdp",
+        description: {
+          type: r.localDescription.type,
+          sdp: r.localDescription.sdp
+        }
+      }));
+      return;
+    }
+    if (s.kind === "ice") {
+      const o = s.candidate;
+      if (r.remoteDescription)
+        try {
+          await r.addIceCandidate(o);
+        } catch (a) {
+          if (!n.ignoreOffer) throw a;
+        }
+      else
+        n.pendingCandidates.push(o);
+      return;
+    }
+  }
+  /* ---- Peer setup --------------------------------------------------- */
+  ensureRemote(e) {
+    const s = this.remotes.get(e.id);
+    if (s) return s;
+    const n = new this.deps.RTCPeerConnection({
+      iceServers: this.iceServers,
+      iceTransportPolicy: "relay"
+    }), r = new this.deps.MediaStream(), o = n.addTransceiver("audio", { direction: "recvonly" }), a = n.addTransceiver("video", { direction: "recvonly" });
+    Ye(o, a);
+    const i = {
+      info: e,
+      pc: n,
+      stream: r,
+      makingOffer: !1,
+      ignoreOffer: !1,
+      pendingCandidates: []
+    };
+    return n.addEventListener("negotiationneeded", () => {
+      (async () => {
+        try {
+          i.makingOffer = !0, await n.setLocalDescription(), n.localDescription && this.sendSignal(e.id, {
+            kind: "sdp",
+            description: {
+              type: n.localDescription.type,
+              sdp: n.localDescription.sdp
+            }
+          });
+        } catch {
+        } finally {
+          i.makingOffer = !1;
+        }
+      })();
+    }), n.addEventListener("icecandidate", (l) => {
+      const c = l.candidate;
+      c && this.sendSignal(e.id, {
+        kind: "ice",
+        candidate: {
+          candidate: c.candidate,
+          sdpMid: c.sdpMid,
+          sdpMLineIndex: c.sdpMLineIndex,
+          usernameFragment: c.usernameFragment
+        }
+      });
+    }), n.addEventListener("track", (l) => {
+      const c = l.track;
+      i.stream.getTracks().includes(c) || i.stream.addTrack(c), c.addEventListener("ended", () => {
+        i.stream.removeTrack(c);
+      }), this.emit("remote-track", {
+        peerId: e.id,
+        peerName: e.name,
+        stream: i.stream
+      });
+    }), n.addEventListener("connectionstatechange", () => {
+      this.emit("connection-state", { peerId: e.id, state: n.connectionState }), (n.connectionState === "failed" || n.connectionState === "closed") && (this.remotes.delete(e.id), this.emit("peer-left", { peerId: e.id, peerName: e.name }));
+    }), this.remotes.set(e.id, i), i;
+  }
+  /* ---- Helpers ------------------------------------------------------ */
+  isPolite(e) {
+    return this.selfId ? this.selfId > e : !1;
+  }
+  sendSignal(e, s) {
+    this.send({ type: "signal", to: e, payload: s });
+  }
+  emit(e, s) {
+    const n = this.listeners.get(e);
+    if (n)
+      for (const r of n) r(s);
+  }
+}
+function Ye(t, e) {
+  const s = globalThis.RTCRtpReceiver?.getCapabilities;
+  typeof s == "function" && (U(e, s("video"), (n) => {
+    const r = n.toLowerCase();
+    return r === "video/h264" || r === "video/rtx";
+  }), U(t, s("audio"), (n) => {
+    const r = n.toLowerCase();
+    return r === "audio/opus" || r === "audio/telephone-event";
+  }));
+}
+function U(t, e, s) {
+  const n = t?.setCodecPreferences;
+  if (typeof n != "function" || !e) return;
+  const r = e.codecs.filter((o) => s(o.mimeType));
+  if (r.length !== 0)
+    try {
+      n.call(t, r);
+    } catch {
+    }
+}
+function X() {
+  const t = /* @__PURE__ */ new Map(), e = /* @__PURE__ */ new Map();
+  function s(n) {
+    const r = e.get(n);
+    if (r === void 0) return;
+    const o = t.get(n) ?? null;
+    for (const a of r) a(o);
+  }
+  return {
+    resolve(n) {
+      return t.get(n) ?? null;
+    },
+    subscribe(n, r) {
+      let o = e.get(n);
+      return o === void 0 && (o = /* @__PURE__ */ new Set(), e.set(n, o)), o.add(r), r(t.get(n) ?? null), () => {
+        const a = e.get(n);
+        a !== void 0 && (a.delete(r), a.size === 0 && e.delete(n));
+      };
+    },
+    set(n, r) {
+      t.get(n) !== r && (t.set(n, r), s(n));
+    },
+    remove(n) {
+      t.has(n) && (t.delete(n), s(n));
+    },
+    clear() {
+      const n = [...t.keys()];
+      t.clear();
+      for (const r of n) s(r);
+    }
+  };
+}
+function g(t) {
+  return t.toLowerCase().replace(/[^a-z0-9_-]+/g, "_").replace(/^[_-]+|[_-]+$/g, "");
+}
+function V(t, e, s) {
+  t.on("remote-track", (n) => {
+    const r = g(n.peerName);
+    s.acquire(r, t) && e.set(r, n.stream);
+  }), t.on("peer-left", (n) => {
+    const r = g(n.peerName);
+    s.acquire(r, t) && (e.remove(r), s.release(r, t));
+  });
+}
+const Je = {
+  acquire: () => !0,
+  release: () => {
+  }
+};
+function pt(t) {
+  const e = X(), s = new K(t);
+  return V(s, e, Je), {
+    join: () => s.join(),
+    leave: () => {
+      s.leave(), e.clear();
+    },
+    resolvePeerStream: (n) => e.resolve(g(n)),
+    subscribePeerStream: (n, r) => e.subscribe(g(n), r),
+    registry: e,
+    viewer: s
+  };
+}
+function $(t) {
+  const e = X(), s = /* @__PURE__ */ new Map(), n = /* @__PURE__ */ new Map(), r = {
+    acquire: (i, l) => {
+      const c = n.get(i);
+      return c === void 0 ? (n.set(i, l), !0) : c === l;
+    },
+    release: (i, l) => {
+      n.get(i) === l && n.delete(i);
+    }
+  };
+  function o(i) {
+    if (s.has(i.roomId)) return;
+    const l = new K({
+      name: i.name ?? "solar-viewer",
+      ...i,
+      ...t.deps !== void 0 && i.deps === void 0 ? { deps: t.deps } : {}
+    });
+    V(l, e, r), s.set(i.roomId, { viewer: l });
+  }
+  function a(i) {
+    const l = s.get(i);
+    if (l !== void 0) {
+      for (const [c, d] of [...n.entries()])
+        d === l.viewer && (e.remove(c), n.delete(c));
+      l.viewer.leave(), s.delete(i);
+    }
+  }
+  for (const i of t.rooms) o(i);
+  return {
+    join: async () => {
+      await Promise.all([...s.values()].map((i) => i.viewer.join()));
+    },
+    leave: () => {
+      for (const i of [...s.keys()]) a(i);
+      e.clear();
+    },
+    setRooms: async (i) => {
+      const l = new Set(i.map((d) => d.roomId));
+      for (const d of [...s.keys()])
+        l.has(d) || a(d);
+      const c = [];
+      for (const d of i)
+        if (!s.has(d.roomId)) {
+          o(d);
+          const h = s.get(d.roomId);
+          h && c.push(h.viewer);
+        }
+      await Promise.all(c.map((d) => d.join()));
+    },
+    resolvePeerStream: (i) => e.resolve(g(i)),
+    subscribePeerStream: (i, l) => e.subscribe(g(i), l),
+    registry: e
+  };
+}
+function gt(t) {
+  if ("rooms" in t && Array.isArray(t.rooms))
+    return $(t);
+  const { name: e, deps: s, ...n } = t;
+  return $({
+    rooms: [{ ...n, ...e !== void 0 ? { name: e } : {} }],
+    ...s !== void 0 ? { deps: s } : {}
+  });
+}
+const Ze = { width: 1920, height: 1080 }, Qe = () => {
+};
+function vt(t) {
+  const e = t.stage ?? Ze, s = t.target;
+  s.style.position ||= "relative", s.style.width = `${e.width}px`, s.style.height = `${e.height}px`, s.style.overflow = "hidden";
+  const n = t.onDiagnostic ? B(t.onDiagnostic) : void 0, r = G();
+  r.reset(t.defaults ?? {});
+  const o = q(s);
+  return {
+    ready: new Promise((i) => {
+      import("./broadcast-L5wm2I6J.js").then(({ BroadcastMode: l }) => {
+        o.render(
+          /* @__PURE__ */ m(re, { children: /* @__PURE__ */ m(
+            z,
+            {
+              value: {
+                mode: "broadcast",
+                store: r,
+                bundle: t.bundle,
+                status: "live",
+                sendInput: Qe
+              },
+              children: /* @__PURE__ */ m(l, {})
+            }
+          ) })
+        );
+        const c = new Promise((h) => {
+          requestAnimationFrame(() => requestAnimationFrame(() => h()));
+        }), d = typeof document < "u" && document.fonts ? document.fonts.ready.then(() => {
+        }) : Promise.resolve();
+        Promise.all([c, d]).then(() => i());
+      });
+    }),
+    unmount() {
+      n?.(), o.unmount();
+    }
+  };
+}
+function Y(t, e) {
+  if (typeof t != "string") return t;
+  if (e[t]) return e[t];
+  const s = /^assets\/([A-Za-z0-9]+)\.[A-Za-z0-9]+$/.exec(t);
+  return s && s[1] !== void 0 && e[s[1]] ? e[s[1]] : t;
+}
+function F(t, e) {
+  if (t === null || typeof t != "object") return;
+  if (Array.isArray(t)) {
+    for (const n of t) F(n, e);
+    return;
+  }
+  const s = t;
+  "src" in s && (s.src = Y(s.src, e));
+  for (const n of Object.values(s))
+    n && typeof n == "object" && F(n, e);
+}
+function wt(t, e) {
+  const s = { ...t };
+  for (const [n, r] of Object.entries(s))
+    n.startsWith("__lit.image.") && (s[n] = Y(r, e));
+  return s;
+}
+async function yt(t) {
+  const e = [];
+  for (const s of t)
+    try {
+      const n = new FontFace(s.family, s.src, {
+        weight: String(s.weight),
+        style: s.style ?? "normal"
+      });
+      await n.load(), document.fonts.add(n), e.push(s.family);
+    } catch {
+    }
+  return e;
+}
+export {
+  we as A,
+  N as B,
+  lt as F,
+  K as M,
+  Xe as P,
+  xe as S,
+  ct as a,
+  mt as b,
+  M as c,
+  B as d,
+  H as e,
+  $ as f,
+  X as g,
+  pt as h,
+  gt as i,
+  yt as j,
+  Ue as k,
+  ft as l,
+  ht as m,
+  vt as n,
+  Y as o,
+  wt as p,
+  F as q,
+  dt as r,
+  Ee as s,
+  ut as t,
+  at as u,
+  x as v,
+  Ie as w
+};
+//# sourceMappingURL=index-Clrya_9l.js.map