@lumencast/runtime 0.1.0

package/dist/index-DUhPPRvw.js

@@ -0,0 +1,583 @@
+import { batch as b, signal as d } from "@preact/signals-react";
+import { createRoot as C } from "react-dom/client";
+import { createContext as U, useContext as x, lazy as S, Suspense as P, createElement as q } from "react";
+import { jsx as l } from "react/jsx-runtime";
+import { useSignals as N } from "@preact/signals-react/runtime";
+import { AnimatePresence as j, motion as W } from "framer-motion";
+import { SequenceTracker as B, encodeFrame as _, input as D, WS_SUBPROTOCOLS as F, WS_SUBPROTOCOL_V1_1 as H, subscribe as z, decodeServerFrame as G, LumencastError as I } from "@lumencast/protocol";
+const O = U(null);
+function K({
+  value: t,
+  children: e
+}) {
+  return /* @__PURE__ */ l(O.Provider, { value: t, children: e });
+}
+function Te() {
+  const t = x(O);
+  if (!t)
+    throw new Error(
+      "Lumencast overlay components must be rendered inside LumencastRuntimeProvider"
+    );
+  return t;
+}
+const J = S(
+  () => import("./broadcast-BqOhSNsY.js").then((t) => ({ default: t.BroadcastMode }))
+), Q = S(
+  () => import("./control-CRFn328D.js").then((t) => ({ default: t.ControlMode }))
+), X = S(() => import("./test-DBCtwx_I.js").then((t) => ({ default: t.TestMode })));
+function Y({
+  mode: t,
+  store: e,
+  bundleSignal: s,
+  statusSignal: n,
+  crossfadeKeySignal: r,
+  sendInput: c
+}) {
+  N();
+  const i = s.value, m = n.value, h = r.value;
+  if (!i) return null;
+  const a = t === "broadcast" ? J : t === "control" ? Q : X;
+  return /* @__PURE__ */ l(j, { mode: "sync", children: /* @__PURE__ */ l(
+    W.div,
+    {
+      initial: { opacity: 0 },
+      animate: { opacity: 1 },
+      exit: { opacity: 0 },
+      transition: { duration: 0.4, ease: "easeInOut" },
+      style: { position: "absolute", inset: 0 },
+      children: /* @__PURE__ */ l(
+        K,
+        {
+          value: {
+            mode: t,
+            store: e,
+            bundle: i,
+            status: m,
+            sendInput: c
+          },
+          children: /* @__PURE__ */ l(P, { fallback: null, children: /* @__PURE__ */ l(a, {}) })
+        }
+      )
+    },
+    h
+  ) });
+}
+const Z = { duration: 0 }, V = {
+  linear: "linear",
+  "cubic-in": "easeIn",
+  "cubic-out": "easeOut",
+  "cubic-in-out": "easeInOut"
+};
+function _e(t) {
+  return !t || t.kind === "none" ? Z : t.kind === "tween" ? {
+    type: "tween",
+    duration: (t.duration_ms ?? 0) / 1e3,
+    ease: t.ease ? V[t.ease] ?? "easeOut" : "easeOut"
+  } : t.kind === "spring" ? {
+    type: "spring",
+    ...t.stiffness !== void 0 ? { stiffness: t.stiffness } : {},
+    ...t.damping !== void 0 ? { damping: t.damping } : {}
+  } : {
+    type: "tween",
+    duration: (t.duration_ms ?? 400) / 1e3,
+    ease: "easeInOut"
+  };
+}
+function ee(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 = te[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), n;
+  }
+}
+const te = {
+  linear: "linear",
+  "ease-in": "cubic-in",
+  "ease-out": "cubic-out",
+  "ease-in-out": "cubic-in-out"
+};
+function se(t, e) {
+  b(() => {
+    for (const s of e.patches) {
+      const n = ee(s.transition);
+      n !== void 0 ? t.setWithTransition(s.path, s.value, n) : t.set(s.path, s.value);
+    }
+  });
+}
+function ne(t, e) {
+  t.reset(e.state);
+}
+class re {
+  signals = /* @__PURE__ */ new Map();
+  transitions = /* @__PURE__ */ new Map();
+  signal(e) {
+    let s = this.signals.get(e);
+    return s || (s = d(void 0), this.signals.set(e, s)), s;
+  }
+  transitionSignal(e) {
+    let s = this.transitions.get(e);
+    return s || (s = d(void 0), this.transitions.set(e, s)), s;
+  }
+  set(e, s) {
+    const n = this.signal(e);
+    v(n.peek(), s) || (n.value = s);
+  }
+  setWithTransition(e, s, n) {
+    b(() => {
+      const r = this.transitionSignal(e);
+      r.peek() !== n && (r.value = n);
+      const c = this.signal(e);
+      v(c.peek(), s) || (c.value = s);
+    });
+  }
+  reset(e) {
+    b(() => {
+      const s = /* @__PURE__ */ new Set();
+      for (const [n, r] of Object.entries(e)) {
+        s.add(n);
+        const c = this.signal(n);
+        v(c.peek(), r) || (c.value = r);
+        const i = this.transitions.get(n);
+        i && i.peek() !== void 0 && (i.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 oe() {
+  return new re();
+}
+function v(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 i = 0; i < t.length; i++)
+      if (t[i] !== e[i]) return !1;
+    return !0;
+  }
+  const s = t, n = e, r = Object.keys(s), c = Object.keys(n);
+  if (r.length !== c.length) return !1;
+  for (const i of r)
+    if (s[i] !== n[i]) return !1;
+  return !0;
+}
+const ie = /* @__PURE__ */ new Set([
+  "x-lumencast.color-srgb-1.0"
+]);
+class ce 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 R(t, e = ie) {
+  const s = t.profiles;
+  if (!s || s.length === 0) return;
+  const n = s.filter((r) => !e.has(r));
+  if (n.length > 0)
+    throw new ce(n);
+}
+class ae {
+  cache = /* @__PURE__ */ new Map();
+  baseUrl;
+  pathPrefix;
+  fetchImpl;
+  constructor(e) {
+    this.baseUrl = e.baseUrl.replace(/\/$/, ""), this.pathPrefix = (e.pathPrefix ?? "/lsdp/v1/scenes").replace(/\/$/, ""), this.fetchImpl = e.fetchImpl ?? globalThis.fetch.bind(globalThis);
+  }
+  preload(e) {
+    R(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.baseUrl}${this.pathPrefix}/${encodeURIComponent(e)}/bundle?v=${encodeURIComponent(s)}`, c = await this.fetchImpl(r);
+    if (!c.ok)
+      throw new Error(`bundle fetch failed: ${c.status} ${c.statusText}`);
+    const i = await c.json();
+    if (i.scene_version !== s)
+      throw new Error(
+        `bundle scene_version mismatch: expected ${s}, got ${i.scene_version}`
+      );
+    return R(i), this.cache.set(s, i), i;
+  }
+}
+function ue(t) {
+  return new ae(t);
+}
+const p = {
+  initial: 200,
+  max: 5e3,
+  factor: 2,
+  jitter: 0.2
+};
+class le {
+  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 he(t = {}) {
+  const e = {
+    initial: t.initial ?? p.initial,
+    max: t.max ?? p.max,
+    factor: t.factor ?? p.factor,
+    jitter: t.jitter ?? p.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 le(e, t.random ?? Math.random);
+}
+class u 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 de {
+  status = "disconnected";
+  socket = null;
+  token;
+  url;
+  WebSocketCtor;
+  schedule;
+  seq = new B();
+  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 = he(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());
+  }
+  /** 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(_(D(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 fe(this.token);
+    } catch (n) {
+      this.opts.onTransportError?.(
+        new u(
+          `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, [...F]);
+    } catch (n) {
+      this.opts.onTransportError?.(
+        new u(
+          `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 === H && this.seq.last > 0, r = n ? this.seq.last : void 0;
+    n || this.seq.reset();
+    const c = z({
+      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));
+  }
+  handleMessage(e) {
+    const s = typeof e.data == "string" ? e.data : "";
+    if (!s) return;
+    let n;
+    try {
+      n = G(s);
+    } catch (r) {
+      const c = (r instanceof I, r.message), i = r instanceof I ? r.code : "INTERNAL";
+      this.opts.onTransportError?.(new u(`codec: ${c}`, !0, i, r)), this.closeSocket(), this.scheduleReconnect();
+      return;
+    }
+    if (n !== null)
+      switch (n.type) {
+        case "snapshot": {
+          if (n.seq < 1) {
+            this.opts.onTransportError?.(
+              new u(`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 u(
+                `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 u(`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 fe(t) {
+  return typeof t == "string" ? t : await t.fetch();
+}
+function pe(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 Ie(t) {
+  pe(t), t.onStatus?.("disconnected");
+  const e = oe(), s = ge(t.serverUrl), n = ue({ baseUrl: s }), r = d(null), c = d("disconnected"), i = d("__initial__"), m = (o) => {
+    c.value = o, t.onStatus?.(o);
+  }, h = (o) => {
+    t.onError?.(o);
+  };
+  let a = !0;
+  const f = new de({
+    url: t.serverUrl,
+    token: t.token,
+    ...t.scene !== void 0 ? { scene: t.scene } : {},
+    ...t.testSession !== void 0 ? { session: t.testSession } : {},
+    onStatus: m,
+    onSnapshot: (o) => {
+      a && (A(
+        n,
+        r,
+        i,
+        o.scene_id,
+        o.scene_version,
+        () => ne(e, o),
+        h
+      ), t.onMetric?.({
+        name: "snapshot_received",
+        scene_id: o.scene_id,
+        path_count: Object.keys(o.state).length
+      }));
+    },
+    onDelta: (o) => {
+      if (!a) return;
+      const g = performance.now();
+      se(e, o), t.onMetric?.({
+        name: "delta_applied",
+        duration_ms: performance.now() - g
+      }), t.onMetric?.({ name: "delta_received", count: 1, path_count: o.patches.length });
+    },
+    onSceneChanged: (o) => {
+      a && t.onMetric?.({
+        name: "scene_changed",
+        from: r.value?.scene_version ?? null,
+        to: o.scene_version
+      });
+    },
+    onServerError: (o) => {
+      h({
+        code: o.code,
+        message: o.message,
+        recoverable: o.recoverable
+      });
+    },
+    onTransportError: (o) => {
+      h(me(o));
+    }
+  });
+  f.start();
+  const k = C(t.target);
+  return k.render(
+    q(Y, {
+      mode: t.mode,
+      store: e,
+      bundleSignal: r,
+      statusSignal: c,
+      crossfadeKeySignal: i,
+      sendInput: (o) => f.sendInput(o)
+    })
+  ), {
+    disconnect() {
+      a && (a = !1, f.close(), k.unmount());
+    },
+    setToken(o) {
+      a && f.setToken(o);
+    }
+  };
+  async function A(o, g, L, w, E, M, $) {
+    let y;
+    try {
+      y = await o.get(w, E);
+    } catch (T) {
+      $({
+        code: "BUNDLE_FETCH_FAILED",
+        message: T instanceof Error ? T.message : "render bundle fetch failed",
+        recoverable: !0
+      });
+      return;
+    }
+    a && (M(), g.value = y, L.value = `${w}::${E}`);
+  }
+}
+function me(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 "";
+  }
+}
+export {
+  Ie as m,
+  _e as t,
+  Te as u
+};
+//# sourceMappingURL=index-DUhPPRvw.js.map