@lumencast/runtime 0.9.0 → 0.11.0

package/dist/index-Dz27r92m.js

@@ -0,0 +1,1327 @@
+import { batch as T, signal as w } from "@preact/signals-react";
+import { createRoot as H } from "react-dom/client";
+import { createContext as oe, useContext as G, lazy as _, Suspense as ae, createElement as ce, StrictMode as le } from "react";
+import { jsx as f } from "react/jsx-runtime";
+import { useSignals as ue } from "@preact/signals-react/runtime";
+import { AnimatePresence as de, motion as he } from "framer-motion";
+import { SequenceTracker as fe, encodeFrame as C, input as me, WS_SUBPROTOCOLS as pe, WS_SUBPROTOCOL_V1_1 as ge, subscribe as ve, decodeServerFrame as we, LumencastError as M } from "@lumencast/protocol";
+const I = oe(null);
+function X({
+  value: t,
+  children: e
+}) {
+  return /* @__PURE__ */ f(I.Provider, { value: t, children: e });
+}
+function mt() {
+  const t = G(I);
+  if (!t)
+    throw new Error(
+      "Lumencast overlay components must be rendered inside LumencastRuntimeProvider"
+    );
+  return t;
+}
+function pt() {
+  return G(I);
+}
+const ye = _(
+  () => import("./broadcast-DtHoU_fS.js").then((t) => ({ default: t.BroadcastMode }))
+), be = _(
+  () => import("./control-B9frEbNG.js").then((t) => ({ default: t.ControlMode }))
+), Se = _(() => import("./test-DD2SBDku.js").then((t) => ({ default: t.TestMode })));
+function ke({
+  mode: t,
+  store: e,
+  bundleSignal: s,
+  statusSignal: n,
+  crossfadeKeySignal: r,
+  sendInput: i,
+  resolveCaptureDevice: a,
+  resolvePeerStream: o,
+  subscribePeerStream: u
+}) {
+  ue();
+  const c = s.value, d = n.value, m = r.value;
+  if (!c) return null;
+  const p = t === "broadcast" ? ye : t === "control" ? be : Se;
+  return /* @__PURE__ */ f(de, { mode: "sync", children: /* @__PURE__ */ f(
+    he.div,
+    {
+      initial: { opacity: 0 },
+      animate: { opacity: 1 },
+      exit: { opacity: 0 },
+      transition: { duration: 0.4, ease: "easeInOut" },
+      style: { position: "absolute", inset: 0 },
+      children: /* @__PURE__ */ f(
+        X,
+        {
+          value: {
+            mode: t,
+            store: e,
+            bundle: c,
+            status: d,
+            sendInput: i,
+            ...a !== void 0 ? { resolveCaptureDevice: a } : {},
+            ...o !== void 0 ? { resolvePeerStream: o } : {},
+            ...u !== void 0 ? { subscribePeerStream: u } : {}
+          },
+          children: /* @__PURE__ */ f(ae, { fallback: null, children: /* @__PURE__ */ f(p, {}) })
+        }
+      )
+    },
+    m
+  ) });
+}
+const Te = "<anon>", b = /* @__PURE__ */ new Set();
+function V(t) {
+  return b.add(t), () => {
+    b.delete(t);
+  };
+}
+function K(t, e, s) {
+  const n = { nodeId: t ?? Te, field: e, reason: s };
+  if (b.size > 0) {
+    for (const r of b)
+      try {
+        r(n);
+      } catch {
+      }
+    return;
+  }
+}
+const Ee = 100, _e = 4, Ie = 64, Re = {
+  blur: Ee,
+  brightness: _e
+};
+function N(t, e) {
+  if (typeof e != "number" || !Number.isFinite(e) || e < 0 || Object.is(e, -0)) return null;
+  const s = Re[t];
+  return e > s ? s : e;
+}
+const Ae = /^blur\((\d{1,7}(?:\.\d{1,4})?)px\) brightness\((\d{1,7}(?:\.\d{1,4})?)\)$/, gt = "blur(0px) brightness(1)";
+function Oe(t) {
+  if (typeof t != "string" || t.length === 0 || t.length > Ie) return null;
+  const e = Ae.exec(t);
+  if (!e) return null;
+  const s = N("blur", Number(e[1])), n = N("brightness", Number(e[2]));
+  return s === null || n === null ? null : `blur(${s}px) brightness(${n})`;
+}
+function Pe(t, e) {
+  K(
+    e,
+    t,
+    "rejected unsafe filter value : outside the R8 caps or not a finite number >= 0"
+  );
+}
+const Le = { duration: 0 }, Ce = {
+  linear: "linear",
+  "cubic-in": "easeIn",
+  "cubic-out": "easeOut",
+  "cubic-in-out": "easeInOut"
+};
+function vt(t) {
+  return !t || t.kind === "none" ? Le : t.kind === "tween" ? {
+    type: "tween",
+    duration: (t.duration_ms ?? 0) / 1e3,
+    ease: t.ease ? Ce[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 Me = {
+  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)"
+}, Ne = {
+  kind: "tween",
+  duration_ms: 400,
+  ease: "cubic-out"
+};
+function wt(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 Ne;
+  }
+}
+function yt(t, e, s) {
+  if (!e || Object.keys(e).length === 0)
+    return { initial: t, animate: t };
+  let n = e;
+  if (e.filter !== void 0) {
+    const i = Oe(e.filter);
+    n = { ...e }, i === null ? (Pe("animate_initial.filter", s), delete n.filter) : n.filter = i;
+  }
+  const r = { ...t };
+  for (const i of Object.keys(n))
+    i in r || (r[i] = Me[i] ?? 0);
+  return { initial: n, animate: r };
+}
+function xe(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 = je[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 je = {
+  linear: "linear",
+  "ease-in": "cubic-in",
+  "ease-out": "cubic-out",
+  "ease-in-out": "cubic-in-out"
+};
+function De(t, e) {
+  T(() => {
+    for (const s of e.patches) {
+      const n = xe(s.transition);
+      n !== void 0 ? t.setWithTransition(s.path, s.value, n) : t.set(s.path, s.value);
+    }
+  });
+}
+function Ue(t, e) {
+  t.reset(e.state);
+}
+const bt = "__cam.", E = "__cam.slots.", J = "__cam.viewer";
+function x(t) {
+  return t === J || t.startsWith(E);
+}
+function $e(t) {
+  const e = {};
+  let s;
+  for (const [n, r] of t)
+    if (n === J)
+      r != null && (s = r);
+    else if (n.startsWith(E)) {
+      const i = n.slice(E.length);
+      i !== "" && typeof r == "string" && r !== "" && (e[i] = r);
+    }
+  return s !== void 0 ? { viewer: s, slots: e } : { slots: e };
+}
+function j(t) {
+  const e = Object.keys(t.slots).sort().map((n) => `${n}=${t.slots[n]}`).join("&"), s = t.viewer === void 0 ? "" : JSON.stringify(t.viewer);
+  return `${e}|${s}`;
+}
+function Fe(t) {
+  const e = /* @__PURE__ */ new Map();
+  let s = j({ slots: {} });
+  const n = () => {
+    const r = $e(e), i = j(r);
+    i !== s && (s = i, t(r));
+  };
+  return {
+    onSnapshot(r) {
+      e.clear();
+      for (const [i, a] of Object.entries(r))
+        x(i) && e.set(i, a);
+      n();
+    },
+    onDelta(r) {
+      let i = !1;
+      for (const a of r)
+        x(a.path) && (e.set(a.path, a.value), i = !0);
+      i && n();
+    }
+  };
+}
+class We {
+  signals = /* @__PURE__ */ new Map();
+  transitions = /* @__PURE__ */ new Map();
+  signal(e) {
+    let s = this.signals.get(e);
+    return s || (s = w(void 0), this.signals.set(e, s)), s;
+  }
+  transitionSignal(e) {
+    let s = this.transitions.get(e);
+    return s || (s = w(void 0), this.transitions.set(e, s)), s;
+  }
+  set(e, s) {
+    const n = this.signal(e);
+    k(n.peek(), s) || (n.value = s);
+  }
+  setWithTransition(e, s, n) {
+    T(() => {
+      const r = this.transitionSignal(e);
+      r.peek() !== n && (r.value = n);
+      const i = this.signal(e);
+      k(i.peek(), s) || (i.value = s);
+    });
+  }
+  reset(e) {
+    T(() => {
+      const s = /* @__PURE__ */ new Set();
+      for (const [n, r] of Object.entries(e)) {
+        s.add(n);
+        const i = this.signal(n);
+        k(i.peek(), r) || (i.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 Y() {
+  return new We();
+}
+function k(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), i = Object.keys(n);
+  if (r.length !== i.length) return !1;
+  for (const a of r)
+    if (s[a] !== n[a]) return !1;
+  return !0;
+}
+const qe = /* @__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"
+]), ze = /^x-[a-z0-9-]+(?:\.[a-z0-9-]+)*$/, Be = /^(?:0|[1-9][0-9]*)$/, D = ".authoring";
+function He(t) {
+  const e = t.indexOf("/");
+  if (e < 0) return !1;
+  const s = t.slice(0, e), n = t.slice(e + 1);
+  return !Be.test(n) || !s.endsWith(D) ? !1 : ze.test(s.slice(0, -D.length));
+}
+class U 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 $(t, e = qe) {
+  const s = t.profiles;
+  if (!s) return;
+  if (!Array.isArray(s))
+    throw new U(["<malformed: profiles is not an array>"]);
+  if (s.length === 0) return;
+  const n = s.filter((r) => typeof r != "string" || !He(r) && !e.has(r)).map((r) => typeof r == "string" ? r : "<malformed: non-string profile entry>");
+  if (n.length > 0)
+    throw new U(n);
+}
+class Ge {
+  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) {
+    $(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), i = await this.buildInit(), a = i ? await this.fetchImpl(r, i) : await this.fetchImpl(r);
+    if (!a.ok)
+      throw new Error(`bundle fetch failed: ${a.status} ${a.statusText}`);
+    const o = await a.json();
+    if (o.scene_version !== s)
+      throw new Error(
+        `bundle scene_version mismatch: expected ${s}, got ${o.scene_version}`
+      );
+    return $(o), this.cache.set(s, o), o;
+  }
+}
+function Xe(t) {
+  return new Ge(t);
+}
+const y = {
+  initial: 200,
+  max: 5e3,
+  factor: 2,
+  jitter: 0.2
+};
+class Ve {
+  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 Ke(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 Ve(e, t.random ?? Math.random);
+}
+class g 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 Je {
+  status = "disconnected";
+  socket = null;
+  token;
+  url;
+  WebSocketCtor;
+  schedule;
+  seq = new fe();
+  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 = Ke(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 F(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(C(me(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 F(this.token);
+    } catch (n) {
+      this.opts.onTransportError?.(
+        new g(
+          `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, [...pe]);
+    } catch (n) {
+      this.opts.onTransportError?.(
+        new g(
+          `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 === ge && this.seq.last > 0, r = n ? this.seq.last : void 0;
+    n || this.seq.reset();
+    const i = ve({
+      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(C(i));
+  }
+  handleMessage(e) {
+    const s = typeof e.data == "string" ? e.data : "";
+    if (!s) return;
+    let n;
+    try {
+      n = we(s);
+    } catch (r) {
+      const i = (r instanceof M, r.message), a = r instanceof M ? r.code : "INTERNAL";
+      this.opts.onTransportError?.(new g(`codec: ${i}`, !0, a, r)), this.closeSocket(), this.scheduleReconnect();
+      return;
+    }
+    if (n !== null)
+      switch (n.type) {
+        case "snapshot": {
+          if (n.seq < 1) {
+            this.opts.onTransportError?.(
+              new g(`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 g(
+                `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 g(`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 F(t) {
+  return typeof t == "string" ? t : await t.fetch();
+}
+function Ye(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 St(t) {
+  Ye(t), t.onStatus?.("disconnected");
+  const e = Y(), s = Qe(t.serverUrl), n = Xe({
+    baseUrl: s,
+    ...t.resolveBundleUrl !== void 0 ? { resolveUrl: t.resolveBundleUrl } : {},
+    getAuthToken: () => p.resolveCurrentToken()
+  }), r = w(null), i = w("disconnected"), a = w("__initial__"), o = (l) => {
+    i.value = l, t.onStatus?.(l);
+  }, u = (l) => {
+    t.onError?.(l);
+  };
+  let c = !0;
+  const d = t.onReservedLeaves ? Fe(t.onReservedLeaves) : void 0, m = t.onDiagnostic ? V(t.onDiagnostic) : void 0, p = new Je({
+    url: t.serverUrl,
+    token: t.token,
+    ...t.scene !== void 0 ? { scene: t.scene } : {},
+    ...t.testSession !== void 0 ? { session: t.testSession } : {},
+    onStatus: o,
+    onSnapshot: (l) => {
+      c && (d?.onSnapshot(l.state), se(
+        n,
+        r,
+        a,
+        l.scene_id,
+        l.scene_version,
+        () => Ue(e, l),
+        u
+      ), t.onMetric?.({
+        name: "snapshot_received",
+        scene_id: l.scene_id,
+        path_count: Object.keys(l.state).length
+      }));
+    },
+    onDelta: (l) => {
+      if (!c) return;
+      const S = performance.now();
+      De(e, l), d?.onDelta(l.patches), t.onMetric?.({
+        name: "delta_applied",
+        duration_ms: performance.now() - S
+      }), t.onMetric?.({ name: "delta_received", count: 1, path_count: l.patches.length });
+    },
+    onSceneChanged: (l) => {
+      c && t.onMetric?.({
+        name: "scene_changed",
+        from: r.value?.scene_version ?? null,
+        to: l.scene_version
+      });
+    },
+    onServerError: (l) => {
+      u({
+        code: l.code,
+        message: l.message,
+        recoverable: l.recoverable
+      });
+    },
+    onTransportError: (l) => {
+      u(Ze(l));
+    }
+  });
+  p.start();
+  const R = H(t.target);
+  return R.render(
+    ce(ke, {
+      mode: t.mode,
+      store: e,
+      bundleSignal: r,
+      statusSignal: i,
+      crossfadeKeySignal: a,
+      sendInput: (l) => p.sendInput(l),
+      // 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, m?.(), p.close(), R.unmount());
+    },
+    setToken(l) {
+      c && p.setToken(l);
+    }
+  };
+  async function se(l, S, ne, A, O, re, ie) {
+    let P;
+    try {
+      P = await l.get(A, O);
+    } catch (L) {
+      ie({
+        code: "BUNDLE_FETCH_FAILED",
+        message: L instanceof Error ? L.message : "render bundle fetch failed",
+        recoverable: !0
+      });
+      return;
+    }
+    c && (re(), S.value = P, ne.value = `${A}::${O}`);
+  }
+}
+function Ze(t) {
+  return {
+    code: t.code,
+    message: t.message,
+    recoverable: t.recoverable
+  };
+}
+function Qe(t) {
+  try {
+    const e = new URL(t);
+    return `${e.protocol === "wss:" ? "https:" : "http:"}//${e.host}`;
+  } catch {
+    return "";
+  }
+}
+const et = [
+  "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 h(t) {
+  return /* @__PURE__ */ new Set([...et, ...t]);
+}
+const tt = {
+  stack: h(["direction", "gap", "wrap", "crossGap", "align", "justify"]),
+  grid: h(["cols", "rows", "gap"]),
+  frame: h([
+    "x",
+    "y",
+    "width",
+    "height",
+    "scale",
+    "rotate",
+    "background",
+    "backgrounds",
+    "clipsContent"
+  ]),
+  text: h([
+    "value",
+    "size",
+    "font",
+    "weight",
+    "colour",
+    "align",
+    "lineHeight",
+    "letterSpacing",
+    "textTransform",
+    "textDecoration",
+    "fontStyle",
+    "maxLines"
+  ]),
+  image: h(["src", "alt", "fit", "position", "width", "height"]),
+  shape: h([
+    "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: h(["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": h([
+    "peer_label",
+    "object_fit",
+    "muted",
+    "x-zab.sourceKind",
+    "metadata",
+    "position",
+    "size"
+  ]),
+  instance: h(["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": h(["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": h(["x-zab.slotRef", "width", "height"]),
+  // `repeat` is dispatched specially by the tree ; its only consumed
+  // binding is `items`.
+  repeat: /* @__PURE__ */ new Set(["items"])
+};
+function st(t, e) {
+  const s = tt[t];
+  return !!(s === void 0 || s.has(e) || t === "instance" && (e === "params" || e.startsWith("params.")));
+}
+const W = /* @__PURE__ */ new WeakSet();
+function kt(t) {
+  if (W.has(t)) return;
+  W.add(t);
+  const e = /* @__PURE__ */ new Set([
+    ...Object.keys(t.props ?? {}),
+    ...Object.keys(t.bindings ?? {})
+  ]);
+  for (const s of e)
+    st(t.kind, s) || K(
+      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 Z {
+  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 i = () => {
+        r.removeEventListener("error", a), this.send({ type: "join", name: this.options.name, role: "viewer" }), s();
+      }, a = (o) => {
+        r.removeEventListener("open", i), n(o);
+      };
+      r.addEventListener("open", i, { once: !0 }), r.addEventListener("error", a, { once: !0 }), r.addEventListener("message", (o) => void this.onMessage(o.data)), r.addEventListener("close", (o) => {
+        this.tearDown(), this.emit("close", { code: o.code, reason: o.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 i = s.description, a = i.type === "offer" && (n.makingOffer || r.signalingState !== "stable");
+      if (n.ignoreOffer = !this.isPolite(e) && a, n.ignoreOffer) return;
+      await r.setRemoteDescription(i);
+      for (const o of n.pendingCandidates)
+        try {
+          await r.addIceCandidate(o);
+        } catch {
+        }
+      n.pendingCandidates = [], i.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 i = s.candidate;
+      if (r.remoteDescription)
+        try {
+          await r.addIceCandidate(i);
+        } catch (a) {
+          if (!n.ignoreOffer) throw a;
+        }
+      else
+        n.pendingCandidates.push(i);
+      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(), i = n.addTransceiver("audio", { direction: "recvonly" }), a = n.addTransceiver("video", { direction: "recvonly" });
+    nt(i, a);
+    const o = {
+      info: e,
+      pc: n,
+      stream: r,
+      makingOffer: !1,
+      ignoreOffer: !1,
+      pendingCandidates: []
+    };
+    return n.addEventListener("negotiationneeded", () => {
+      (async () => {
+        try {
+          o.makingOffer = !0, await n.setLocalDescription(), n.localDescription && this.sendSignal(e.id, {
+            kind: "sdp",
+            description: {
+              type: n.localDescription.type,
+              sdp: n.localDescription.sdp
+            }
+          });
+        } catch {
+        } finally {
+          o.makingOffer = !1;
+        }
+      })();
+    }), n.addEventListener("icecandidate", (u) => {
+      const c = u.candidate;
+      c && this.sendSignal(e.id, {
+        kind: "ice",
+        candidate: {
+          candidate: c.candidate,
+          sdpMid: c.sdpMid,
+          sdpMLineIndex: c.sdpMLineIndex,
+          usernameFragment: c.usernameFragment
+        }
+      });
+    }), n.addEventListener("track", (u) => {
+      const c = u.track;
+      o.stream.getTracks().includes(c) || o.stream.addTrack(c), c.addEventListener("ended", () => {
+        o.stream.removeTrack(c);
+      }), this.emit("remote-track", {
+        peerId: e.id,
+        peerName: e.name,
+        stream: o.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, o), o;
+  }
+  /* ---- 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 nt(t, e) {
+  const s = globalThis.RTCRtpReceiver?.getCapabilities;
+  typeof s == "function" && (q(e, s("video"), (n) => {
+    const r = n.toLowerCase();
+    return r === "video/h264" || r === "video/rtx";
+  }), q(t, s("audio"), (n) => {
+    const r = n.toLowerCase();
+    return r === "audio/opus" || r === "audio/telephone-event";
+  }));
+}
+function q(t, e, s) {
+  const n = t?.setCodecPreferences;
+  if (typeof n != "function" || !e) return;
+  const r = e.codecs.filter((i) => s(i.mimeType));
+  if (r.length !== 0)
+    try {
+      n.call(t, r);
+    } catch {
+    }
+}
+function Q() {
+  const t = /* @__PURE__ */ new Map(), e = /* @__PURE__ */ new Map();
+  function s(n) {
+    const r = e.get(n);
+    if (r === void 0) return;
+    const i = t.get(n) ?? null;
+    for (const a of r) a(i);
+  }
+  return {
+    resolve(n) {
+      return t.get(n) ?? null;
+    },
+    subscribe(n, r) {
+      let i = e.get(n);
+      return i === void 0 && (i = /* @__PURE__ */ new Set(), e.set(n, i)), i.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 v(t) {
+  return t.toLowerCase().replace(/[^a-z0-9_-]+/g, "_").replace(/^[_-]+|[_-]+$/g, "");
+}
+function ee(t, e, s) {
+  t.on("remote-track", (n) => {
+    const r = v(n.peerName);
+    s.acquire(r, t) && e.set(r, n.stream);
+  }), t.on("peer-left", (n) => {
+    const r = v(n.peerName);
+    s.acquire(r, t) && (e.remove(r), s.release(r, t));
+  });
+}
+const rt = {
+  acquire: () => !0,
+  release: () => {
+  }
+};
+function Tt(t) {
+  const e = Q(), s = new Z(t);
+  return ee(s, e, rt), {
+    join: () => s.join(),
+    leave: () => {
+      s.leave(), e.clear();
+    },
+    resolvePeerStream: (n) => e.resolve(v(n)),
+    subscribePeerStream: (n, r) => e.subscribe(v(n), r),
+    registry: e,
+    viewer: s
+  };
+}
+function z(t) {
+  const e = Q(), s = /* @__PURE__ */ new Map(), n = /* @__PURE__ */ new Map(), r = {
+    acquire: (o, u) => {
+      const c = n.get(o);
+      return c === void 0 ? (n.set(o, u), !0) : c === u;
+    },
+    release: (o, u) => {
+      n.get(o) === u && n.delete(o);
+    }
+  };
+  function i(o) {
+    if (s.has(o.roomId)) return;
+    const u = new Z({
+      name: o.name ?? "solar-viewer",
+      ...o,
+      ...t.deps !== void 0 && o.deps === void 0 ? { deps: t.deps } : {}
+    });
+    ee(u, e, r), s.set(o.roomId, { viewer: u });
+  }
+  function a(o) {
+    const u = s.get(o);
+    if (u !== void 0) {
+      for (const [c, d] of [...n.entries()])
+        d === u.viewer && (e.remove(c), n.delete(c));
+      u.viewer.leave(), s.delete(o);
+    }
+  }
+  for (const o of t.rooms) i(o);
+  return {
+    join: async () => {
+      await Promise.all([...s.values()].map((o) => o.viewer.join()));
+    },
+    leave: () => {
+      for (const o of [...s.keys()]) a(o);
+      e.clear();
+    },
+    setRooms: async (o) => {
+      const u = new Set(o.map((d) => d.roomId));
+      for (const d of [...s.keys()])
+        u.has(d) || a(d);
+      const c = [];
+      for (const d of o)
+        if (!s.has(d.roomId)) {
+          i(d);
+          const m = s.get(d.roomId);
+          m && c.push(m.viewer);
+        }
+      await Promise.all(c.map((d) => d.join()));
+    },
+    resolvePeerStream: (o) => e.resolve(v(o)),
+    subscribePeerStream: (o, u) => e.subscribe(v(o), u),
+    registry: e
+  };
+}
+function Et(t) {
+  if ("rooms" in t && Array.isArray(t.rooms))
+    return z(t);
+  const { name: e, deps: s, ...n } = t;
+  return z({
+    rooms: [{ ...n, ...e !== void 0 ? { name: e } : {} }],
+    ...s !== void 0 ? { deps: s } : {}
+  });
+}
+const it = { width: 1920, height: 1080 }, ot = () => {
+};
+function _t(t) {
+  const e = t.stage ?? it, 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 ? V(t.onDiagnostic) : void 0, r = Y();
+  r.reset(t.defaults ?? {});
+  const i = H(s);
+  return {
+    ready: new Promise((o) => {
+      import("./broadcast-DtHoU_fS.js").then(({ BroadcastMode: u }) => {
+        i.render(
+          /* @__PURE__ */ f(le, { children: /* @__PURE__ */ f(
+            X,
+            {
+              value: {
+                mode: "broadcast",
+                store: r,
+                bundle: t.bundle,
+                status: "live",
+                sendInput: ot
+              },
+              children: /* @__PURE__ */ f(u, {})
+            }
+          ) })
+        );
+        const c = new Promise((m) => {
+          requestAnimationFrame(() => requestAnimationFrame(() => m()));
+        }), d = typeof document < "u" && document.fonts ? document.fonts.ready.then(() => {
+        }) : Promise.resolve();
+        Promise.all([c, d]).then(() => o());
+      });
+    }),
+    unmount() {
+      n?.(), i.unmount();
+    }
+  };
+}
+function te(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 B(t, e) {
+  if (t === null || typeof t != "object") return;
+  if (Array.isArray(t)) {
+    for (const n of t) B(n, e);
+    return;
+  }
+  const s = t;
+  "src" in s && (s.src = te(s.src, e));
+  for (const n of Object.values(s))
+    n && typeof n == "object" && B(n, e);
+}
+function It(t, e) {
+  const s = { ...t };
+  for (const [n, r] of Object.entries(s))
+    n.startsWith("__lit.image.") && (s[n] = te(r, e));
+  return s;
+}
+async function Rt(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 {
+  Te as A,
+  U as B,
+  bt as C,
+  gt as F,
+  Z as M,
+  tt as P,
+  qe as S,
+  pt as a,
+  kt as b,
+  N as c,
+  E as d,
+  K as e,
+  J as f,
+  V as g,
+  z as h,
+  Q as i,
+  Tt as j,
+  Et as k,
+  Rt as l,
+  yt as m,
+  He as n,
+  x as o,
+  St as p,
+  _t as q,
+  wt as r,
+  Oe as s,
+  vt as t,
+  mt as u,
+  te as v,
+  Pe as w,
+  It as x,
+  B as y,
+  $ as z
+};
+//# sourceMappingURL=index-Dz27r92m.js.map