@vincentt-xr/sdk 2.0.0-alpha.7 → 2.0.0-alpha.8

package/dist/index-CnGox6Xr.js

@@ -0,0 +1,3054 @@
+var ns = Object.defineProperty;
+var rs = (t, s, e) => s in t ? ns(t, s, { enumerable: !0, configurable: !0, writable: !0, value: e }) : t[s] = e;
+var d = (t, s, e) => rs(t, typeof s != "symbol" ? s + "" : s, e);
+import { jsxs as as, jsx as et } from "react/jsx-runtime";
+import { useRef as ie, useMemo as he, useEffect as ce, useContext as De, useCallback as tt, createElement as is, createContext as ut, useState as os } from "react";
+import { FilesetResolver as j, PoseLandmarker as cs, FaceLandmarker as ls, GestureRecognizer as ds, HolisticLandmarker as us, HandLandmarker as hs, ImageSegmenter as ht, DrawingUtils as ms } from "@mediapipe/tasks-vision";
+import * as B from "three";
+import { RGBAFormat as mt, LinearFilter as pe, CanvasTexture as ft, SRGBColorSpace as fs } from "three";
+const gs = (t, s) => s, U = {
+  apiBaseUrl: gs(void 0, "https://api.vincentt.studio"),
+  // Pinned to the CDN, NOT build-env-driven: a stale VITE_ASSET_STORAGE_ENDPOINT
+  // baked a now-deleted CloudFront domain into every published bundle, breaking
+  // WASM/model loads at runtime. The host must never come from a mutable env value.
+  assetStorageEndpoint: "https://cdn.vincentt.studio",
+  // Versioned bucket for SDK-shipped reference assets (canonical face model, face textures, etc.).
+  sdkAssetsBaseUrl: "https://cdn.vincentt.studio/assets/sdk/face/v1",
+  loggerPrefix: "[vincentt-xr]:",
+  sessionCheckInterval: 3e4
+};
+var F = /* @__PURE__ */ ((t) => (t.WEBCAM = "webcam", t.STREAM = "stream", t.CANVAS = "canvas", t))(F || {}), R = /* @__PURE__ */ ((t) => (t.HAND_TRACKER = "vincentt.xr.hand-tracker", t.GESTURE_TRACKER = "vincentt.xr.gesture-tracker", t.FACE_TRACKER = "vincentt.xr.face-tracker", t.BODY_TRACKER = "vincentt.xr.body-tracker", t.HOLISTIC_TRACKER = "vincentt.xr.holistic-tracker", t.BACKGROUND_SEGMENTATION = "vincentt.xr.background-segmentation", t.SEMANTIC_SEGMENTATION = "vincentt.xr.semantic-segmentation", t))(R || {});
+const Ee = (t) => Array.from({ length: t }, () => ({ x: 0, y: 0, z: 0 }));
+class ps {
+  constructor(s) {
+    d(this, "slots", []);
+    this.options = s;
+  }
+  setOptions(s) {
+    this.options = s;
+  }
+  /** Landmark sets to draw this frame: live faces, plus held/predicted ones. */
+  update(s, e) {
+    const { holdMs: n, predictMs: r, maxVelocityGapMs: a = 250 } = this.options, o = [], c = Math.max(s.length, this.slots.length);
+    for (let l = 0; l < c; l += 1) {
+      const h = s[l], f = this.slots[l] ?? null;
+      if (h && h.length > 0) {
+        const S = f && f.points.length === h.length ? f : null, k = S ?? {
+          points: Ee(h.length),
+          velocity: Ee(h.length),
+          lastSeen: e,
+          output: Ee(h.length)
+        }, x = (e - k.lastSeen) / 1e3, T = S !== null && x > 0 && x * 1e3 <= a;
+        for (let _ = 0; _ < h.length; _ += 1) {
+          const g = h[_], v = k.points[_], y = k.velocity[_], C = g.z ?? 0;
+          T ? (y.x = 0.5 * y.x + 0.5 * ((g.x - v.x) / x), y.y = 0.5 * y.y + 0.5 * ((g.y - v.y) / x), y.z = 0.5 * y.z + 0.5 * ((C - v.z) / x)) : (y.x = 0, y.y = 0, y.z = 0), v.x = g.x, v.y = g.y, v.z = C;
+        }
+        k.lastSeen = e, this.slots[l] = k, o.push(h);
+        continue;
+      }
+      if (!f) continue;
+      const u = e - f.lastSeen;
+      if (u > n) {
+        this.slots[l] = null;
+        continue;
+      }
+      const w = Math.max(0, Math.min(u, r)) / 1e3;
+      for (let S = 0; S < f.points.length; S += 1)
+        f.output[S].x = f.points[S].x + f.velocity[S].x * w, f.output[S].y = f.points[S].y + f.velocity[S].y * w, f.output[S].z = f.points[S].z + f.velocity[S].z * w;
+      o.push(f.output);
+    }
+    for (; this.slots.length > 0 && this.slots[this.slots.length - 1] === null; ) this.slots.pop();
+    return o;
+  }
+  reset() {
+    this.slots = [];
+  }
+}
+const le = (t, s = { x: 0, y: 0, z: 0 }) => (s.x = t.x * 2 - 1, s.y = 1 - t.y * 2, s.z = -t.z, s), Qn = (t, s = { x: 0, y: 0, z: 0 }) => (s.x = (t.x + 1) / 2, s.y = (1 - t.y) / 2, s.z = -t.z, s), gt = "https://storage.googleapis.com/mediapipe-models/holistic_landmarker/holistic_landmarker/float16/latest/holistic_landmarker.task", ys = 250, ws = 0, vs = 768, Pe = (t) => ({
+  hands: (t == null ? void 0 : t.hands) ?? "both",
+  analysisMaxDimension: (t == null ? void 0 : t.analysisMaxDimension) ?? vs,
+  holdMs: (t == null ? void 0 : t.holdMs) ?? ys,
+  predictMs: (t == null ? void 0 : t.predictMs) ?? ws
+}), Ss = () => ({
+  version: 0,
+  timestampMs: 0,
+  face: null,
+  leftHand: null,
+  rightHand: null,
+  pose: null
+}), st = [
+  0,
+  4,
+  5,
+  6,
+  1,
+  2,
+  3,
+  8,
+  7,
+  10,
+  9,
+  12,
+  11,
+  14,
+  13,
+  16,
+  15,
+  18,
+  17,
+  20,
+  19,
+  22,
+  21,
+  24,
+  23,
+  26,
+  25,
+  28,
+  27,
+  30,
+  29,
+  32,
+  31
+], nt = (t, s) => {
+  if (t.length !== st.length) return t;
+  s.length = t.length;
+  for (let e = 0; e < t.length; e += 1) s[e] = t[st[e]];
+  return s;
+};
+class ge {
+  constructor(s, e) {
+    d(this, "memory");
+    d(this, "holdMs");
+    d(this, "lastLiveMs", -1 / 0);
+    d(this, "lastConfidence", 0);
+    this.holdMs = s, this.memory = new ps({ holdMs: s, predictMs: e });
+  }
+  setOptions(s, e) {
+    this.holdMs = s, this.memory.setOptions({ holdMs: s, predictMs: e });
+  }
+  reset() {
+    this.memory.reset(), this.lastLiveMs = -1 / 0, this.lastConfidence = 0;
+  }
+  /**
+   * Returns the landmarks to publish this frame (live, or replayed from
+   * memory), or `undefined` when the stream is neither detected nor held.
+   * A held stream's confidence decays linearly from the last live value to
+   * 0 at `holdMs`.
+   */
+  bridge(s, e, n) {
+    const r = s !== void 0 && s.length > 0, a = this.memory.update(r ? [s] : [], n)[0];
+    if (!a) return;
+    if (r)
+      return this.lastLiveMs = n, this.lastConfidence = e, { points: a, held: !1, confidence: e };
+    const o = n - this.lastLiveMs, c = this.holdMs > 0 ? Math.max(0, 1 - o / this.holdMs) : 0;
+    return { points: a, held: !0, confidence: this.lastConfidence * c };
+  }
+}
+const ae = (t, s, e) => {
+  for (t.length > s && (t.length = s); t.length < s; ) t.push(e());
+  return t;
+}, Ae = (t, s) => {
+  t.x = s.x, t.y = s.y, t.z = s.z;
+}, Ms = (t) => {
+  if (t.length === 0) return 0;
+  let s = 0;
+  for (let e = 0; e < t.length; e += 1) s += t[e].visibility ?? 0;
+  return s / t.length;
+};
+class ks {
+  constructor(s) {
+    d(this, "options", Pe());
+    d(this, "faceMemory", new ge(this.options.holdMs, this.options.predictMs));
+    d(this, "leftHandMemory", new ge(this.options.holdMs, this.options.predictMs));
+    d(this, "rightHandMemory", new ge(this.options.holdMs, this.options.predictMs));
+    d(this, "poseMemory", new ge(this.options.holdMs, this.options.predictMs));
+    d(this, "face", {
+      landmarks: [],
+      blendshapes: {},
+      confidence: 0,
+      held: !1
+    });
+    d(this, "leftHand", {
+      handedness: "left",
+      landmarks: [],
+      worldLandmarks: [],
+      confidence: 0,
+      held: !1
+    });
+    d(this, "rightHand", {
+      handedness: "right",
+      landmarks: [],
+      worldLandmarks: [],
+      confidence: 0,
+      held: !1
+    });
+    d(this, "poseScratch", []);
+    d(this, "poseWorldScratch", []);
+    d(this, "pose", {
+      landmarks: [],
+      worldLandmarks: [],
+      visibility: [],
+      confidence: 0,
+      held: !1
+    });
+    this.setOptions(s);
+  }
+  getOptions() {
+    return this.options;
+  }
+  setOptions(s) {
+    this.options = Pe({ ...this.options, ...s });
+    const { holdMs: e, predictMs: n } = this.options;
+    for (const r of this.memories()) r.setOptions(e, n);
+  }
+  reset() {
+    for (const s of this.memories()) s.reset();
+  }
+  memories() {
+    return [this.faceMemory, this.leftHandMemory, this.rightHandMemory, this.poseMemory];
+  }
+  /**
+   * Publish `raw` (or a miss when `undefined`) into `result` at `nowMs`.
+   *
+   * `mirrored` says the analysed frame is a mirror of the person (the
+   * session's webcam feed). Pose left/right follow the image, and holistic
+   * assigns hands from the pose, so on a mirrored frame MediaPipe's "left"
+   * is the person's right. Swap both the hands and the pose's left/right
+   * landmarks so the whole result is anatomical and self-consistent
+   * (`leftHand` and pose wrist 15 are the same physical hand), matching the
+   * convention `HandTracker` reports on that feed.
+   */
+  update(s, e, n, r = !1) {
+    var h, f, u, w;
+    n.face = this.updateFace(s, e);
+    const a = {
+      landmarks: (h = s == null ? void 0 : s.leftHandLandmarks) == null ? void 0 : h[0],
+      world: (f = s == null ? void 0 : s.leftHandWorldLandmarks) == null ? void 0 : f[0]
+    }, o = {
+      landmarks: (u = s == null ? void 0 : s.rightHandLandmarks) == null ? void 0 : u[0],
+      world: (w = s == null ? void 0 : s.rightHandWorldLandmarks) == null ? void 0 : w[0]
+    }, c = r ? o : a, l = r ? a : o;
+    return n.leftHand = this.updateHand("left", c.landmarks, c.world, e), n.rightHand = this.updateHand("right", l.landmarks, l.world, e), n.pose = this.updatePose(s, e, r), n.timestampMs = e, n.version += 1, n;
+  }
+  updateFace(s, e) {
+    var c, l, h, f;
+    const n = (c = s == null ? void 0 : s.faceLandmarks) == null ? void 0 : c[0], r = this.faceMemory.bridge(n, 1, e);
+    if (!r) return null;
+    const { face: a } = this, o = !r.held && n;
+    ae(a.landmarks, r.points.length, () => ({
+      x: 0,
+      y: 0,
+      z: 0,
+      visibility: 0
+    }));
+    for (let u = 0; u < r.points.length; u += 1) {
+      const w = a.landmarks[u];
+      Ae(w, r.points[u]), w.visibility = o ? ((l = n[u]) == null ? void 0 : l.visibility) ?? 0 : 0;
+    }
+    if (o) {
+      const u = (f = (h = s == null ? void 0 : s.faceBlendshapes) == null ? void 0 : h[0]) == null ? void 0 : f.categories;
+      if (u)
+        for (const w of u) a.blendshapes[w.categoryName] = w.score;
+    }
+    return a.confidence = r.confidence, a.held = r.held, a;
+  }
+  updateHand(s, e, n, r) {
+    const a = s === "left" ? this.leftHandMemory : this.rightHandMemory, { hands: o } = this.options;
+    if (o === "none" || o !== "both" && o !== s)
+      return a.reset(), null;
+    const c = a.bridge(e, 1, r);
+    if (!c) return null;
+    const l = s === "left" ? this.leftHand : this.rightHand;
+    ae(l.landmarks, c.points.length, () => ({ x: 0, y: 0, z: 0 }));
+    for (let h = 0; h < c.points.length; h += 1)
+      le(c.points[h], l.landmarks[h]);
+    if (!c.held && n) {
+      ae(l.worldLandmarks, n.length, () => ({ x: 0, y: 0, z: 0 }));
+      for (let h = 0; h < n.length; h += 1) Ae(l.worldLandmarks[h], n[h]);
+    }
+    return l.confidence = c.confidence, l.held = c.held, l;
+  }
+  updatePose(s, e, n) {
+    var u, w, S;
+    const r = (u = s == null ? void 0 : s.poseLandmarks) == null ? void 0 : u[0], a = r && n ? nt(r, this.poseScratch) : r, o = this.poseMemory.bridge(a, a ? Ms(a) : 0, e);
+    if (!o) return null;
+    const { pose: c } = this, l = !o.held && a;
+    ae(c.landmarks, o.points.length, () => ({ x: 0, y: 0, z: 0 })), ae(c.visibility, o.points.length, () => 0);
+    for (let k = 0; k < o.points.length; k += 1)
+      le(o.points[k], c.landmarks[k]), l && (c.visibility[k] = ((w = a[k]) == null ? void 0 : w.visibility) ?? 0);
+    const h = (S = s == null ? void 0 : s.poseWorldLandmarks) == null ? void 0 : S[0], f = h && n ? nt(h, this.poseWorldScratch) : h;
+    if (l && f) {
+      ae(c.worldLandmarks, f.length, () => ({ x: 0, y: 0, z: 0 }));
+      for (let k = 0; k < f.length; k += 1) Ae(c.worldLandmarks[k], f[k]);
+    }
+    return c.confidence = o.confidence, c.held = o.held, c;
+  }
+}
+const pt = {
+  "camera-permission-denied": "Camera access was blocked. Allow camera permissions in your browser, then refresh.",
+  "camera-in-use": "Camera is already in use by another app or browser tab. Close it and refresh.",
+  "no-camera": "No camera was found on this device.",
+  "camera-insecure-context": "Camera access needs HTTPS (or localhost). Open the page over HTTPS.",
+  "camera-unsupported": "This browser cannot open the camera.",
+  "camera-lost": "The camera stopped sending frames (disconnected, revoked, or taken by another app).",
+  "webgl-unavailable": "WebGL is unavailable, so nothing can render or track.",
+  "offscreen-canvas-unavailable": "OffscreenCanvas is unavailable; the tracker feed cannot be built.",
+  "wasm-unavailable": "WebAssembly is unavailable; the tracking engine cannot load.",
+  "model-unreachable": "The tracker model could not be downloaded.",
+  "model-integrity": "The tracker model failed its integrity check.",
+  "model-init-failed": "The tracker failed to initialize on this device.",
+  "placement-unsupported": "This device cannot place 3D objects in the room (no WebXR, Scene Viewer or Quick Look).",
+  unknown: "Tracking is unavailable for an unknown reason."
+}, Cs = {
+  "camera-permission-denied": !0,
+  "camera-in-use": !0,
+  "no-camera": !1,
+  "camera-insecure-context": !1,
+  "camera-unsupported": !1,
+  "camera-lost": !0,
+  "webgl-unavailable": !1,
+  "offscreen-canvas-unavailable": !1,
+  "wasm-unavailable": !1,
+  "model-unreachable": !0,
+  "model-integrity": !1,
+  "model-init-failed": !1,
+  "placement-unsupported": !1,
+  unknown: !0
+}, I = (t, s = pt[t]) => ({ code: t, message: s, recoverable: Cs[t] }), xs = {
+  [R.FACE_TRACKER]: "/assets/xr/models/face_tracking.task",
+  [R.HAND_TRACKER]: "/assets/xr/models/hand_tracking.task",
+  [R.GESTURE_TRACKER]: "/assets/xr/models/gesture_tracking.task",
+  [R.BODY_TRACKER]: "/assets/xr/models/body_tracking.task",
+  [R.BACKGROUND_SEGMENTATION]: "/assets/xr/models/segmentation.tflite",
+  [R.SEMANTIC_SEGMENTATION]: "/assets/xr/models/selfie_multiclass_256x256.tflite",
+  [R.HOLISTIC_TRACKER]: gt
+}, yt = (t) => {
+  const s = xs[t];
+  return s ? /^https?:/.test(s) ? s : new URL(s, U.assetStorageEndpoint).toString() : null;
+}, bs = Object.values(R), Ts = () => {
+  var e, n, r;
+  const t = typeof window < "u", s = typeof document < "u";
+  return {
+    navigator: typeof navigator < "u" ? navigator : void 0,
+    isSecureContext: t ? window.isSecureContext : void 0,
+    createCanvas: s ? () => document.createElement("canvas") : void 0,
+    offscreenCanvas: typeof OffscreenCanvas < "u",
+    wasm: typeof WebAssembly < "u",
+    fetch: typeof fetch < "u" ? fetch.bind(globalThis) : void 0,
+    now: () => typeof performance < "u" ? performance.now() : Date.now(),
+    xrSessionSupported: typeof navigator < "u" && ((e = navigator.xr) != null && e.isSessionSupported) ? (a) => navigator.xr.isSessionSupported(a).catch(() => !1) : void 0,
+    relSupportsAr: s ? ((r = (n = document.createElement("a").relList) == null ? void 0 : n.supports) == null ? void 0 : r.call(n, "ar")) === !0 : void 0,
+    userAgent: typeof navigator < "u" ? navigator.userAgent : void 0
+  };
+}, Es = (t) => !!t && /Android/.test(t) && /(Chrome|SamsungBrowser)\//.test(t) && !/Firefox|OPR\//.test(t), As = async (t) => {
+  let s = !1;
+  if (t.xrSessionSupported)
+    try {
+      s = await t.xrSessionSupported("immersive-ar");
+    } catch {
+      s = !1;
+    }
+  const e = Es(t.userAgent), n = t.relSupportsAr === !0, r = s || e || n;
+  return {
+    webxr: s,
+    sceneViewer: e,
+    quickLook: n,
+    any: r,
+    reason: r ? null : I("placement-unsupported")
+  };
+}, Rs = (t) => {
+  switch (t) {
+    case "granted":
+      return "supported";
+    case "denied":
+      return "permission-denied";
+    case "prompt":
+      return "permission-prompt";
+    default:
+      return "unknown";
+  }
+}, Fs = async (t, s) => {
+  var c, l, h;
+  const e = t.isSecureContext ?? !0, n = (c = t.navigator) == null ? void 0 : c.mediaDevices;
+  if (!e)
+    return {
+      status: "unsupported",
+      reason: I("camera-insecure-context"),
+      deviceCount: null,
+      secureContext: e
+    };
+  if (!n || typeof n.getUserMedia != "function")
+    return {
+      status: "unsupported",
+      reason: I("camera-unsupported"),
+      deviceCount: null,
+      secureContext: e
+    };
+  let r = "unknown";
+  if (s && ((h = (l = t.navigator) == null ? void 0 : l.permissions) != null && h.query))
+    try {
+      const f = await t.navigator.permissions.query({ name: "camera" });
+      r = Rs(f.state);
+    } catch {
+      r = "unknown";
+    }
+  let a = null, o = !1;
+  if (typeof n.enumerateDevices == "function")
+    try {
+      const f = await n.enumerateDevices();
+      a = f.filter((u) => u.kind === "videoinput").length, o = f.some((u) => !!u.label);
+    } catch {
+      a = null;
+    }
+  return r === "permission-denied" ? {
+    status: r,
+    reason: I("camera-permission-denied"),
+    deviceCount: a,
+    secureContext: e
+  } : a === 0 && (r === "supported" || o) ? {
+    status: "unsupported",
+    reason: I("no-camera"),
+    deviceCount: a,
+    secureContext: e
+  } : { status: r, reason: null, deviceCount: a, secureContext: e };
+}, Is = (t) => {
+  var e;
+  const s = (e = t.createCanvas) == null ? void 0 : e.call(t);
+  if (!s) return 0;
+  try {
+    if (s.getContext("webgl2")) return 2;
+    if (s.getContext("webgl") || s.getContext("experimental-webgl")) return 1;
+  } catch {
+    return 0;
+  }
+  return 0;
+}, _s = (t) => {
+  var o;
+  const s = Is(t), e = t.offscreenCanvas ?? !1, n = t.wasm ?? !1, r = !!((o = t.navigator) != null && o.gpu);
+  let a = null;
+  return s === 0 ? a = I("webgl-unavailable") : e ? n || (a = I("wasm-unavailable")) : a = I("offscreen-canvas-unavailable"), {
+    status: a ? "unsupported" : "supported",
+    reason: a,
+    webglVersion: s,
+    webgpu: r,
+    offscreenCanvas: e,
+    wasm: n
+  };
+}, Ps = async (t, s, e) => {
+  var o, c;
+  const n = yt(t);
+  if (!n || !s.fetch)
+    return { model: t, status: "unknown", reason: null, url: n, bytes: null };
+  const r = typeof AbortController < "u" ? new AbortController() : void 0, a = setTimeout(() => r == null ? void 0 : r.abort(), e);
+  try {
+    const l = await s.fetch(n, { method: "HEAD", signal: r == null ? void 0 : r.signal });
+    if (!l.ok)
+      return {
+        model: t,
+        status: "unsupported",
+        reason: I(
+          "model-unreachable",
+          `${pt["model-unreachable"]} (${l.status})`
+        ),
+        url: n,
+        bytes: null
+      };
+    const h = Number(((c = (o = l.headers) == null ? void 0 : o.get) == null ? void 0 : c.call(o, "content-length")) ?? NaN);
+    return {
+      model: t,
+      status: "supported",
+      reason: null,
+      url: n,
+      bytes: Number.isFinite(h) && h > 0 ? h : null
+    };
+  } catch {
+    return {
+      model: t,
+      status: "unsupported",
+      reason: I("model-unreachable"),
+      url: n,
+      bytes: null
+    };
+  } finally {
+    clearTimeout(a);
+  }
+}, jn = async (t = {}, s = Ts()) => {
+  const e = t.timeoutMs ?? 4e3, n = new Set(t.models ?? []), [r, a, o] = await Promise.all([
+    Fs(s, t.queryPermission ?? !0),
+    Promise.all(
+      bs.map(
+        async (h) => n.has(h) ? Ps(h, s, e) : {
+          model: h,
+          status: "unknown",
+          reason: null,
+          url: yt(h),
+          bytes: null
+        }
+      )
+    ),
+    As(s)
+  ]), c = _s(s), l = Object.fromEntries(a.map((h) => [h.model, h]));
+  return {
+    camera: r,
+    rendering: c,
+    placement: o,
+    models: l,
+    canRunTracking: c.status === "supported" && r.status !== "unsupported",
+    checkedAt: s.now ? s.now() : Date.now()
+  };
+}, wt = (t) => {
+  switch (t) {
+    case "permission-denied":
+      return I("camera-permission-denied");
+    case "camera-in-use":
+      return I("camera-in-use");
+    case "no-camera":
+      return I("no-camera");
+    case "camera-lost":
+      return I("camera-lost");
+    case "unsupported":
+      return I("camera-unsupported");
+    default:
+      return I("unknown");
+  }
+}, Zn = (t, s) => {
+  const { camera: e, rendering: n } = t, r = t.models[s], a = e.status === "permission-prompt" || e.status === "unknown";
+  return n.reason ? { supported: !1, reason: n.reason, needsPermission: a } : e.reason ? { supported: !1, reason: e.reason, needsPermission: a } : r != null && r.reason ? { supported: !1, reason: r.reason, needsPermission: a } : { supported: !0, reason: null, needsPermission: a };
+}, $n = (t) => {
+  const s = t instanceof Error ? t.message : String(t ?? ""), e = s.toLowerCase();
+  return e.includes("integrity") || e.includes("sha-384") || e.includes("sha384") ? I("model-integrity", s) : e.includes("failed to fetch") || e.includes("networkerror") || e.includes("load failed") || /\b(404|403|5\d\d)\b/.test(e) || e.includes("fetch") ? I("model-unreachable", s) : e.includes("webgl") || e.includes("gpu") ? I("webgl-unavailable", s) : s ? I("model-init-failed", s) : I("unknown");
+}, vt = (t) => {
+  switch (t instanceof DOMException ? t.name : "") {
+    case "NotAllowedError":
+    case "PermissionDeniedError":
+      return "permission-denied";
+    case "NotReadableError":
+    case "TrackStartError":
+      return "camera-in-use";
+    case "NotFoundError":
+    case "DevicesNotFoundError":
+      return "no-camera";
+    case "NotSupportedError":
+    case "SecurityError":
+    case "OverconstrainedError":
+      return "unsupported";
+    default:
+      return t instanceof TypeError ? "unsupported" : "unknown";
+  }
+}, rt = {
+  "permission-denied": "Camera access was blocked. Allow camera permissions in your browser, then refresh.",
+  "camera-in-use": "Camera is already in use by another app or browser tab. Close it and refresh.",
+  "no-camera": "No camera was found on this device.",
+  "camera-lost": "The camera stopped sending frames. Reconnect it or re-allow access, then start again.",
+  unsupported: "Unable to access camera. Allow camera permissions in your browser, then refresh.",
+  unknown: "Unable to access camera. Allow camera permissions in your browser, then refresh."
+}, Oe = () => ({
+  mediaDevices: typeof navigator < "u" ? navigator.mediaDevices : void 0,
+  permissions: typeof navigator < "u" ? navigator.permissions : void 0,
+  isSecureContext: typeof window < "u" ? window.isSecureContext : void 0
+}), St = async (t = Oe()) => {
+  var s;
+  if (!((s = t.permissions) != null && s.query)) return { state: "unknown", prompt: !1 };
+  try {
+    const e = await t.permissions.query({ name: "camera" });
+    return e.state === "granted" ? { state: "granted", prompt: !1 } : e.state === "denied" ? { state: "blocked", prompt: !1 } : { state: "unknown", prompt: e.state === "prompt" };
+  } catch {
+    return { state: "unknown", prompt: !1 };
+  }
+}, Mt = (t, s) => t === "permission-denied" ? {
+  state: s === "blocked" ? "blocked" : "denied",
+  reason: I("camera-permission-denied")
+} : { state: "unavailable", reason: wt(t) }, Jn = async (t = {}, s = Oe()) => {
+  var n;
+  if (s.isSecureContext === !1)
+    return {
+      state: "unavailable",
+      reason: I("camera-insecure-context"),
+      stream: null
+    };
+  const e = (n = s.mediaDevices) == null ? void 0 : n.getUserMedia;
+  if (typeof e != "function")
+    return {
+      state: "unavailable",
+      reason: I("camera-unsupported"),
+      stream: null
+    };
+  try {
+    const r = await e.call(
+      s.mediaDevices,
+      t.constraints ?? { video: { facingMode: "user" } }
+    );
+    return t.keepStream ? { state: "granted", reason: null, stream: r } : (r.getTracks().forEach((a) => a.stop()), { state: "granted", reason: null, stream: null });
+  } catch (r) {
+    const a = vt(r), o = await St(s);
+    return { ...Mt(a, o.state), stream: null };
+  }
+}, er = async (t, s = Oe()) => {
+  var e, n;
+  if (!((e = s.permissions) != null && e.query)) return () => {
+  };
+  try {
+    const r = await s.permissions.query({ name: "camera" }), a = () => {
+      r.state === "granted" ? t({ state: "granted", prompt: !1 }) : r.state === "denied" ? t({ state: "blocked", prompt: !1 }) : t({ state: "unknown", prompt: r.state === "prompt" });
+    };
+    return (n = r.addEventListener) == null || n.call(r, "change", a), () => {
+      var o;
+      return (o = r.removeEventListener) == null ? void 0 : o.call(r, "change", a);
+    };
+  } catch {
+    return () => {
+    };
+  }
+}, tr = (t) => t === "unknown" || t === "denied" || t === "granted", sr = {
+  unknown: "This experience uses your camera. Nothing is recorded or uploaded.",
+  requesting: "Waiting for you to allow the camera…",
+  granted: "Camera access granted.",
+  denied: "Camera access was not allowed. You can try again.",
+  blocked: "Camera access is blocked for this site. Allow it in your browser's site settings, then reload.",
+  unavailable: "The camera is unavailable on this device right now."
+}, Ls = (t, s, e = "cover", n = 1) => {
+  if (t.width <= 0 || t.height <= 0 || s.width <= 0 || s.height <= 0)
+    return null;
+  const r = Number.isFinite(n) && n > 0 ? n : 1, a = s.width / t.width, o = s.height / t.height, c = e === "contain" ? o <= a : o >= a, l = (c ? o : a) * r, h = c ? t.width * o * r : s.width * r, f = c ? s.height * r : t.height * a * r;
+  return {
+    scale: l,
+    drawWidth: h,
+    drawHeight: f,
+    offsetX: (s.width - h) / 2,
+    offsetY: (s.height - f) / 2
+  };
+}, He = (t) => t === "webcam" || t === void 0, Ds = ({
+  source: t,
+  feed: s,
+  zoom: e = 1,
+  mirrored: n = !1
+}) => {
+  const r = Ls(t, s, "cover", e);
+  return r ? { ...r, source: t, feed: s, zoom: Number.isFinite(e) && e > 0 ? e : 1, mirrored: n } : null;
+}, nr = (t, s, e = { x: 0, y: 0 }) => {
+  const n = s.mirrored ? s.source.width - t.x : t.x;
+  return e.x = (s.offsetX + n * s.scale) / s.feed.width, e.y = (s.offsetY + t.y * s.scale) / s.feed.height, e;
+}, Os = (t, s, e = { x: 0, y: 0 }) => {
+  const n = (t.x * s.feed.width - s.offsetX) / s.scale;
+  return e.x = s.mirrored ? s.source.width - n : n, e.y = (t.y * s.feed.height - s.offsetY) / s.scale, e;
+}, rr = (t, s) => {
+  const e = Os(t, s);
+  return e.x >= 0 && e.x <= s.source.width && e.y >= 0 && e.y <= s.source.height;
+}, ar = (t, s = { x: 0, y: 0 }) => (s.x = 1 - t.x, s.y = t.y, t.z !== void 0 && (s.z = t.z), s), ir = (t, s, e, n = { x: 0, y: 0 }) => {
+  switch (e) {
+    case 90:
+      return n.x = s.height - t.y, n.y = t.x, n;
+    case 180:
+      return n.x = s.width - t.x, n.y = s.height - t.y, n;
+    case 270:
+      return n.x = t.y, n.y = s.width - t.x, n;
+    default:
+      return n.x = t.x, n.y = t.y, n;
+  }
+}, or = (t, s) => s === 90 || s === 270 ? { width: t.height, height: t.width } : { width: t.width, height: t.height };
+class O extends Error {
+  constructor(s) {
+    super(s), this.name = "VincenttXRError";
+  }
+}
+class Hs {
+  constructor(s) {
+    d(this, "options");
+    const e = {
+      verbose: !1,
+      prefix: U.loggerPrefix
+    };
+    this.options = { ...e, ...s };
+  }
+  log(...s) {
+    const { verbose: e, prefix: n } = this.options;
+    e && console.info(n, ...s);
+  }
+  error(...s) {
+    const { verbose: e, prefix: n } = this.options;
+    e && console.error(n, ...s);
+  }
+}
+const at = new B.Vector3(), Re = new B.Vector3(), kt = (t, s, e, n, r) => {
+  at.set(t, s, 0).unproject(e), Re.copy(at).sub(e.position).normalize();
+  const a = (n - e.position.z) / Re.z;
+  return r.copy(e.position).addScaledVector(Re, a);
+}, Us = (t, s, e = new B.Vector3(), n = 0) => kt((t.x - 0.5) * 2, (0.5 - t.y) * 2, s, n, e), cr = (t, s, e = new B.Vector3(), n = 0) => kt(t.x, t.y, s, n, e), X = new B.Vector3(), lr = (t, s, e = { x: 0, y: 0, z: 0 }) => (X.set(t.x, t.y, t.z).project(s), e.x = X.x / 2 + 0.5, e.y = 0.5 - X.y / 2, e.z = X.z, e), dr = (t, s, e = { x: 0, y: 0, z: 0 }) => (X.set(t.x, t.y, t.z).project(s), e.x = X.x, e.y = X.y, e.z = X.z, e), Fe = (t, s, e) => Us(t, s, e, 0), Ns = (t, s, e = 0.2) => e * s + (1 - e) * t;
+class de {
+  constructor(s) {
+    d(this, "canvas");
+    d(this, "scale", 1);
+    this.maxDimension = s;
+  }
+  /** Multiply the cap (0.25..1); the adaptive-quality tier sets it. */
+  setScale(s) {
+    this.scale = Math.min(1, Math.max(0.25, Number.isFinite(s) && s > 0 ? s : 1));
+  }
+  /**
+   * Returns a downscaled copy of `source` capped to `maxDimension` on its
+   * longest side (or `source` unchanged if it's already within the cap, or if a
+   * 2D context can't be obtained). The returned canvas is reused across calls.
+   */
+  draw(s) {
+    const e = s.width, n = s.height, r = Math.min(
+      1,
+      this.maxDimension * this.scale / Math.max(e, n)
+    );
+    if (r >= 1) return s;
+    const a = Math.max(1, Math.round(e * r)), o = Math.max(1, Math.round(n * r));
+    (!this.canvas || this.canvas.width !== a || this.canvas.height !== o) && (this.canvas = new OffscreenCanvas(a, o));
+    const c = this.canvas.getContext("2d");
+    return c ? (c.setTransform(1, 0, 0, 1, 0, 0), c.clearRect(0, 0, a, o), c.drawImage(s, 0, 0, a, o), this.canvas) : s;
+  }
+  dispose() {
+    this.canvas = void 0;
+  }
+}
+const Bs = {
+  "/assets/xr/models/face_tracking.task": "sha384-tYQh+yJE8llY+zO4RviZmWaSKs5W9tsB0ix5rjQVpF5/CLTqmwtP7bYtkUi2w65P",
+  "/assets/xr/models/hand_tracking.task": "sha384-uWvruVKd887ov8k43S+DBHCsi7UXXS+CKvvdM1PX00rjPzx/B0QrAPfJ1U9yKcze",
+  "/assets/xr/models/gesture_tracking.task": "sha384-2zuseP9JKKWAYlWQGKA2N+ooabB8V/yIxu23Mv8mtY7SowcySB+xKiOmqBhVvlUC",
+  "/assets/xr/models/body_tracking.task": "sha384-3Wk9dvRYo36b3Nc9xVjKamb4wCKt9FwiPjcHKfrvyJL/jXoGs+uRLnii6yjWLKul",
+  "/assets/xr/models/segmentation.tflite": "sha384-A2bQ8+iZyQM3KIGVBUf0FyetqxuynyKpjsjCE8uzoJEnj1ghCu6ge2daiRffAiS5",
+  "/assets/xr/3d-models/head-occluder-v2.glb": "sha384-+0G60Q6EBVE6hpITxGzQgofAeKexPltpsfPq5T5et9GGBjRhFP5HOdsKAhe73OaI",
+  // Category segmenters behind XRModel.SEMANTIC_SEGMENTATION. The same bytes
+  // are pinned under the SDK CDN paths (not yet published) and under
+  // MediaPipe's published paths, which the presets load by default.
+  "/assets/xr/models/hair_segmenter.tflite": "sha384-1Eu/EdJcYV/7talPYVVbxPZBLg7UIxqsKisUNh/pEsyvAuUcE49HuqijSXWSHXHK",
+  "/mediapipe-models/image_segmenter/hair_segmenter/float32/latest/hair_segmenter.tflite": "sha384-1Eu/EdJcYV/7talPYVVbxPZBLg7UIxqsKisUNh/pEsyvAuUcE49HuqijSXWSHXHK",
+  "/assets/xr/models/selfie_multiclass_256x256.tflite": "sha384-LPLPyzBZ6TTE8146rnDx8CZ5LykB8memkmeO8FNVbGlNthvlUltn3W3KeJmtq9bL",
+  "/mediapipe-models/image_segmenter/selfie_multiclass_256x256/float32/latest/selfie_multiclass_256x256.tflite": "sha384-LPLPyzBZ6TTE8146rnDx8CZ5LykB8memkmeO8FNVbGlNthvlUltn3W3KeJmtq9bL",
+  // MediaPipe Holistic Landmarker (face + hands + pose in one graph) behind
+  // XRModel.HOLISTIC_TRACKER. Same bytes pinned under the SDK CDN path (not yet
+  // published) and MediaPipe's published path, which the tracker loads by default.
+  "/assets/xr/models/holistic_landmarker.task": "sha384-6Y2fQ5yP5QtlvJIasfv0fHEyoMqRYYpLtEpsyeXjYDOuFCEXfKIZPZSXq8TLXmsg",
+  "/mediapipe-models/holistic_landmarker/holistic_landmarker/float16/latest/holistic_landmarker.task": "sha384-6Y2fQ5yP5QtlvJIasfv0fHEyoMqRYYpLtEpsyeXjYDOuFCEXfKIZPZSXq8TLXmsg",
+  "/assets/sdk/face/v1/canonical_face_model.obj": "sha384-xP8YM/72TXKvbMptXB9a8JUlUf3MZQ8uLurExrsZc05v6/P5RrsaNGMUYS/BZx8A",
+  "/opencv/facial_expression_recognition/resolve/main/facial_expression_recognition_mobilefacenet_2022july_int8.onnx": "sha384-g8mtFubiIc/yhqi591RsxD76AJLw2CfYgKhKbVkIiFlwBmIyG7ZAIVyGPXafrDGB"
+};
+async function zs(t, s) {
+  const e = await fetch(t, s != null && s.signal ? { signal: s.signal } : void 0);
+  if (!e.ok)
+    throw new Error(`fetchAndVerify: ${e.status} ${t}`);
+  const n = await e.arrayBuffer(), r = Vs(t);
+  if (!r) {
+    if (Ws(t))
+      throw new Error(`[xr-sdk integrity] no SRI hash for SDK asset ${t}`);
+    return console.warn(`[xr-sdk integrity] no SRI hash for ${t} — passing through`), n;
+  }
+  const a = await qs(n);
+  if (a !== r)
+    throw new Error(
+      `[xr-sdk integrity] SRI mismatch for ${t}: expected ${r}, got ${a}`
+    );
+  return n;
+}
+function Ws(t) {
+  try {
+    return new URL(t).origin === new URL(U.assetStorageEndpoint).origin;
+  } catch {
+    return !1;
+  }
+}
+async function Z(t) {
+  const s = await zs(t);
+  return new Uint8Array(s);
+}
+function Vs(t) {
+  try {
+    const s = new URL(t);
+    return Bs[s.pathname];
+  } catch {
+    return;
+  }
+}
+async function qs(t) {
+  const s = await crypto.subtle.digest("SHA-384", t), e = new Uint8Array(s);
+  let n = "";
+  for (let r = 0; r < e.byteLength; r++)
+    n += String.fromCharCode(e[r]);
+  return `sha384-${btoa(n)}`;
+}
+const Ie = /* @__PURE__ */ new Map();
+function $(t) {
+  const s = t.wasmBinaryPath;
+  let e = Ie.get(s);
+  return e || (e = Ks(s).catch(() => {
+    Ie.delete(s);
+  }), Ie.set(s, e)), e;
+}
+async function Ks(t) {
+  const s = await fetch(t, { credentials: "same-origin" });
+  if (!s.ok || !s.body)
+    throw new Error(`warmVisionWasm: ${s.status} ${t}`);
+  const e = s.body.getReader();
+  for (; ; ) {
+    const { done: n } = await e.read();
+    if (n) return;
+  }
+}
+class J {
+  constructor() {
+    d(this, "disposed", !1);
+    d(this, "paused", !1);
+    d(this, "rafId", null);
+    // Inference bookkeeping behind `getDiagnostics()`. Subclasses call
+    // `recordInference(startMs)` right after their detect call and
+    // `recordDetections(count, confidence)` after reading the result.
+    d(this, "statInferenceMs", null);
+    d(this, "statInferences", 0);
+    d(this, "statWindowStart", 0);
+    d(this, "statWindowCount", 0);
+    d(this, "statFps", 0);
+    d(this, "statSkipped", 0);
+    d(this, "statDetections", null);
+    d(this, "statConfidence", null);
+    d(this, "statStatus", "ready");
+    d(this, "statError", null);
+    // Inference-rate throttle. `targetFrameIntervalMs` is 0 when uncapped
+    // (detect every frame); a positive value skips detection until that many ms
+    // have elapsed since the last inference. `run()` sets this from
+    // `params.targetFps`; subclasses call `shouldRunInference()` in their RAF
+    // loop to gate the expensive MediaPipe call.
+    d(this, "targetFrameIntervalMs", 0);
+    d(this, "lastInferenceMs", 0);
+    /** Analysis-resolution multiplier (0.25..1) from the quality tier; subclasses read it where they downscale. */
+    d(this, "analysisScale", 1);
+  }
+  /** Record one completed inference that started at `startMs` (`performance.now()`). */
+  recordInference(s, e = performance.now()) {
+    const n = e - s;
+    this.statInferenceMs = n, this.statInferences += 1, this.statWindowCount += 1, this.statWindowStart === 0 && (this.statWindowStart = e);
+    const r = e - this.statWindowStart;
+    return r >= 1e3 && (this.statFps = this.statWindowCount * 1e3 / r, this.statWindowStart = e, this.statWindowCount = 0), n;
+  }
+  /** Record what the last inference found (subjects and the primary confidence). */
+  recordDetections(s, e = null) {
+    this.statDetections = s, this.statConfidence = e;
+  }
+  /** Record an inference failure (or clear it with `null`). */
+  recordInferenceError(s) {
+    this.statStatus = s ? "error" : "ready", this.statError = s;
+  }
+  /** Current health snapshot. Allocates a small object; sample it at UI rate, not per frame. */
+  getDiagnostics() {
+    const s = this.statWindowStart > 0 && performance.now() - this.statWindowStart > 1500;
+    return {
+      inferenceMs: this.statInferenceMs,
+      inferenceFps: s ? 0 : this.statFps,
+      inferences: this.statInferences,
+      skippedFrames: this.statSkipped,
+      detections: this.statDetections,
+      confidence: this.statConfidence,
+      status: this.statStatus,
+      error: this.statError,
+      paused: this.paused,
+      disposed: this.disposed
+    };
+  }
+  /** Clamp and store the analysis scale; subclasses with a downscaler forward it. */
+  setAnalysisScale(s) {
+    this.analysisScale = s !== void 0 && Number.isFinite(s) && s > 0 ? Math.min(1, Math.max(0.25, s)) : 1;
+  }
+  /** Set the per-frame inference cap. fps <= 0 (or undefined) → uncapped. */
+  setTargetFps(s) {
+    this.targetFrameIntervalMs = s && s > 0 ? 1e3 / s : 0;
+  }
+  /**
+   * True if enough time has elapsed to run inference this frame (and records
+   * the timestamp). Always true when uncapped. Call once per RAF tick, right
+   * before the detect call; skip the detect (but keep rescheduling RAF) when
+   * it returns false.
+   */
+  shouldRunInference() {
+    if (this.targetFrameIntervalMs <= 0) return !0;
+    const s = performance.now();
+    return s - this.lastInferenceMs < this.targetFrameIntervalMs ? (this.statSkipped += 1, !1) : (this.lastInferenceMs = s, !0);
+  }
+  // load models
+  async initialize(s) {
+  }
+  // setup for running + start running
+  async run(s) {
+  }
+  // get model's data while processing
+  getModelNode() {
+    return {};
+  }
+  async getPerformanceData() {
+    return {
+      name: this.constructor.name,
+      processingTime: null
+    };
+  }
+  // Cancel the per-frame RAF loop without releasing MediaPipe resources or
+  // dropping refs. Subclasses' process* methods check `paused` and return
+  // without rescheduling. Idempotent.
+  pause() {
+    this.paused = !0, this.rafId !== null && (cancelAnimationFrame(this.rafId), this.rafId = null);
+  }
+  // Resume a paused loop by running the process function once. Subclasses
+  // override to kick their specific process* method. Idempotent — no-op if
+  // not paused. Calling resume() before run() is a no-op.
+  resume() {
+    this.paused = !1;
+  }
+  // Release MediaPipe landmarkers, cancel rAF loops, drop refs.
+  // Subclasses MUST override and call super.dispose() at the end.
+  dispose() {
+    this.disposed = !0, this.rafId !== null && (cancelAnimationFrame(this.rafId), this.rafId = null);
+  }
+}
+const Gs = 768;
+class Xs extends J {
+  constructor() {
+    super();
+    d(this, "landmarker", null);
+    d(this, "processingTime", null);
+    d(this, "coordinates");
+    d(this, "sourceCanvas");
+    d(this, "downscaler", new de(Gs));
+  }
+  async getBodyData() {
+    if (!this.landmarker || !this.sourceCanvas)
+      return;
+    const e = this.downscaler.draw(this.sourceCanvas), n = performance.now(), r = this.landmarker.detectForVideo(e, n), a = performance.now();
+    this.processingTime = a - n, this.recordInference(n, a);
+    const o = r.landmarks, c = o == null ? void 0 : o[0];
+    this.recordDetections(
+      (o == null ? void 0 : o.length) ?? 0,
+      c && c.length ? c.reduce((h, f) => h + (f.visibility ?? 0), 0) / c.length : null
+    );
+    const l = [];
+    if (o)
+      return o.forEach((h, f) => {
+        l[f] || (l[f] = []), h.forEach((u) => {
+          l[f].push(le(u));
+        });
+      }), {
+        coordinatesList: l
+      };
+  }
+  async processBodyTracking() {
+    if (!(this.disposed || this.paused || !this.landmarker)) {
+      if (this.shouldRunInference()) {
+        const e = await this.getBodyData();
+        e && (this.coordinates = e.coordinatesList);
+      }
+      this.disposed || this.paused || (this.rafId = requestAnimationFrame(this.processBodyTracking.bind(this)));
+    }
+  }
+  resume() {
+    this.paused && (super.resume(), this.processBodyTracking());
+  }
+  dispose() {
+    if (super.dispose(), this.landmarker) {
+      try {
+        this.landmarker.close();
+      } catch {
+      }
+      this.landmarker = null;
+    }
+    this.sourceCanvas = void 0, this.downscaler.dispose(), this.coordinates = void 0;
+  }
+  getLandmarks2D(e = 0) {
+    if (this.coordinates)
+      return this.coordinates[e];
+  }
+  async initialize(e) {
+    const n = await j.forVisionTasks(
+      new URL("/assets/xr/wasm", U.assetStorageEndpoint).toString()
+    ), [r] = await Promise.all([
+      Z(
+        new URL("/assets/xr/models/body_tracking.task", U.assetStorageEndpoint).toString()
+      ),
+      $(n)
+    ]);
+    this.landmarker = await cs.createFromOptions(n, {
+      baseOptions: {
+        modelAssetBuffer: r,
+        delegate: "GPU"
+      },
+      runningMode: "VIDEO",
+      numPoses: (e == null ? void 0 : e.numPoses) || 1
+    });
+  }
+  async run({ sourceCanvas: e, targetFps: n, analysisScale: r }) {
+    this.setAnalysisScale(r), this.downscaler.setScale(this.analysisScale), this.sourceCanvas = e, this.setTargetFps(n), this.rafId === null && await this.processBodyTracking();
+  }
+  getModelNode() {
+    return {
+      getLandmarks2D: this.getLandmarks2D.bind(this)
+    };
+  }
+  async getPerformanceData() {
+    return {
+      name: this.constructor.name,
+      processingTime: this.processingTime
+    };
+  }
+}
+const Ys = 0.11, Qs = 4e-3, js = (t, s) => s.set(t.x, -t.y, t.z);
+class Zs extends J {
+  constructor() {
+    super();
+    d(this, "landmarker", null);
+    d(this, "processingTime", null);
+    d(this, "sourceCanvas");
+    d(this, "analysisCanvas");
+    d(this, "getSource");
+    d(this, "detectionResults");
+    d(this, "numFaces", 1);
+    d(this, "cameras", []);
+    // camera object to unproject each face's translation
+    d(this, "faces", []);
+    // Reused per-face work vectors. Allocated once per face index and mutated
+    // in place each frame, so the published Face[] doesn't churn the GC at
+    // 30+ fps. Per-face indexing means two faces don't alias each other's
+    // transforms; consumers see "current value" each frame.
+    d(this, "leftCheekScratch", []);
+    d(this, "rightCheekScratch", []);
+    // Reused per-frame landmark used to feed unprojectToZZeroInto with an
+    // x-mirrored copy for non-webcam sources, without allocating a new
+    // landmark array (~468 entries) each frame.
+    d(this, "landmarkScratch", { x: 0, y: 0, z: 0, visibility: 0 });
+    // Reused per-frame rotation scratch (matrix -> quaternion -> mirror -> euler),
+    // allocated once to avoid per-frame churn at 30+ fps.
+    d(this, "rotMatrixScratch", new B.Matrix4());
+    d(this, "rotQuatScratch", new B.Quaternion());
+    d(this, "rotEulerScratch", new B.Euler());
+  }
+  // For non-webcam sources MediaPipe landmarks read as mirrored; flip x in
+  // place into the reused scratch so downstream unprojection sees the
+  // corrected position. Webcam input is already correct, so it's returned
+  // by reference.
+  landmarkForSource(e, n) {
+    return n ? (this.landmarkScratch.x = 1 - e.x, this.landmarkScratch.y = e.y, this.landmarkScratch.z = e.z, this.landmarkScratch.visibility = e.visibility, this.landmarkScratch) : e;
+  }
+  extractAndUpdateFaceData(e) {
+    var r;
+    if (!e.faceLandmarks.length) {
+      this.faces = [];
+      return;
+    }
+    const n = e.faceLandmarks.length;
+    for (this.faces.length > n && (this.faces.length = n, this.leftCheekScratch.length = n, this.rightCheekScratch.length = n); this.faces.length < n; )
+      this.faces.push({
+        transform: {
+          position: new B.Vector3(),
+          rotation: new B.Vector3(),
+          scale: new B.Vector3()
+        },
+        gestures: {}
+      }), this.leftCheekScratch.push(new B.Vector3()), this.rightCheekScratch.push(new B.Vector3());
+    for (let a = 0; a < n; a += 1) {
+      if (!this.cameras[a])
+        continue;
+      const o = this.faces[a], c = !He((r = this.getSource) == null ? void 0 : r.call(this)), l = e.faceLandmarks[a], h = e.facialTransformationMatrixes[a];
+      this.rotMatrixScratch.fromArray(h.data), this.rotQuatScratch.setFromRotationMatrix(this.rotMatrixScratch), this.rotQuatScratch.set(
+        -this.rotQuatScratch.x,
+        this.rotQuatScratch.y,
+        this.rotQuatScratch.z,
+        this.rotQuatScratch.w
+      ), this.rotEulerScratch.setFromQuaternion(this.rotQuatScratch, "XYZ"), js(this.rotEulerScratch, o.transform.rotation), Fe(
+        this.landmarkForSource(l[4], c),
+        this.cameras[a],
+        o.transform.position
+      ), Fe(
+        this.landmarkForSource(l[50], c),
+        this.cameras[a],
+        this.leftCheekScratch[a]
+      ), Fe(
+        this.landmarkForSource(l[280], c),
+        this.cameras[a],
+        this.rightCheekScratch[a]
+      );
+      const u = this.leftCheekScratch[a].distanceTo(this.rightCheekScratch[a]) * Ys, w = Math.abs(B.MathUtils.radToDeg(this.rotEulerScratch.y)), S = u + w * Qs, k = o.transform.scale.x, x = Ns(
+        isNaN(k) ? 0 : k,
+        S
+      );
+      o.transform.scale.set(x, x, x);
+      const T = o.gestures, _ = e.faceBlendshapes[a].categories;
+      for (const g of _)
+        T[g.categoryName] = g.score;
+    }
+  }
+  async processFaceTracking() {
+    if (this.disposed || this.paused || !this.landmarker || !this.sourceCanvas)
+      return null;
+    if (!this.shouldRunInference()) {
+      this.rafId = requestAnimationFrame(this.processFaceTracking.bind(this));
+      return;
+    }
+    const e = $s(this.numFaces) * this.analysisScale, n = this.sourceCanvas.width, r = this.sourceCanvas.height, a = Math.min(1, e / Math.max(n, r)), o = Math.max(1, Math.round(n * a)), c = Math.max(1, Math.round(r * a));
+    (!this.analysisCanvas || this.analysisCanvas.width !== o || this.analysisCanvas.height !== c) && (this.analysisCanvas = new OffscreenCanvas(o, c));
+    const l = this.analysisCanvas.getContext("2d");
+    if (!l) {
+      this.rafId = requestAnimationFrame(this.processFaceTracking.bind(this));
+      return;
+    }
+    l.setTransform(1, 0, 0, 1, 0, 0), l.clearRect(0, 0, o, c), l.drawImage(this.sourceCanvas, 0, 0, o, c);
+    const h = performance.now(), f = this.landmarker.detectForVideo(this.analysisCanvas, h), u = performance.now();
+    this.processingTime = u - h, this.recordInference(h, u), this.recordDetections(f.faceLandmarks.length, null), this.detectionResults = f, this.extractAndUpdateFaceData(f), !(this.disposed || this.paused) && (this.rafId = requestAnimationFrame(this.processFaceTracking.bind(this)));
+  }
+  resume() {
+    this.paused && (super.resume(), this.processFaceTracking());
+  }
+  dispose() {
+    if (super.dispose(), this.landmarker) {
+      try {
+        this.landmarker.close();
+      } catch {
+      }
+      this.landmarker = null;
+    }
+    this.sourceCanvas = void 0, this.analysisCanvas = void 0, this.getSource = void 0, this.detectionResults = void 0, this.processingTime = null, this.cameras = [], this.faces = [], this.leftCheekScratch = [], this.rightCheekScratch = [];
+  }
+  getFace(e = 0) {
+    return this.faces[e];
+  }
+  getDetectionResults() {
+    return this.detectionResults;
+  }
+  getRawFaceTrackingData(e = 0) {
+    var n, r, a, o;
+    if (this.detectionResults)
+      return {
+        landmarks: (n = this.detectionResults.faceLandmarks) == null ? void 0 : n[e],
+        blendshapes: (a = (r = this.detectionResults.faceBlendshapes) == null ? void 0 : r[e]) == null ? void 0 : a.categories,
+        transformationMatrix: (o = this.detectionResults.facialTransformationMatrixes) == null ? void 0 : o[e]
+      };
+  }
+  async initialize(e) {
+    this.numFaces = (e == null ? void 0 : e.numFaces) || 1;
+    const n = await j.forVisionTasks(
+      new URL("/assets/xr/wasm", U.assetStorageEndpoint).toString()
+    ), [r] = await Promise.all([
+      Z(
+        new URL("/assets/xr/models/face_tracking.task", U.assetStorageEndpoint).toString()
+      ),
+      $(n)
+    ]), a = await ls.createFromOptions(n, {
+      baseOptions: {
+        modelAssetBuffer: r,
+        delegate: "GPU"
+      },
+      // Keep detection permissive for calibration workflows with dark webcam input.
+      minFaceDetectionConfidence: 0.3,
+      minFacePresenceConfidence: 0.3,
+      minTrackingConfidence: 0.3,
+      outputFaceBlendshapes: !0,
+      outputFacialTransformationMatrixes: !0,
+      runningMode: "VIDEO",
+      numFaces: this.numFaces
+    });
+    if (this.disposed) {
+      a.close();
+      return;
+    }
+    this.landmarker = a;
+  }
+  async run({
+    sourceCanvas: e,
+    getSource: n,
+    targetFps: r,
+    analysisScale: a
+  }) {
+    this.sourceCanvas = e, this.getSource = n, this.setTargetFps(r), this.setAnalysisScale(a), this.analysisCanvas = void 0, this.rafId === null && this.processFaceTracking();
+  }
+  getModelNode() {
+    const e = this;
+    return {
+      get detectionResults() {
+        return e.detectionResults;
+      },
+      getDetectionResults: this.getDetectionResults.bind(this),
+      getFace: this.getFace.bind(this),
+      getRawFaceTrackingData: this.getRawFaceTrackingData.bind(this),
+      setCamera: (r, a = 0) => {
+        this.cameras[a] = r;
+      }
+    };
+  }
+  async getPerformanceData() {
+    return {
+      name: this.constructor.name,
+      processingTime: this.processingTime
+    };
+  }
+}
+const $s = (t) => t > 1 ? 1024 : 512;
+var G = /* @__PURE__ */ ((t) => (t.ClosedFist = "closed_fist", t.OpenPalm = "open_palm", t.PointingUp = "pointing_up", t.ThumbDown = "thumb_down", t.ThumbUp = "thumb_up", t.Victory = "victory", t.ILoveYou = "i_love_you", t.None = "none", t))(G || {});
+const Js = 512, en = {
+  Closed_Fist: G.ClosedFist,
+  Open_Palm: G.OpenPalm,
+  Pointing_Up: G.PointingUp,
+  Thumb_Down: G.ThumbDown,
+  Thumb_Up: G.ThumbUp,
+  Victory: G.Victory,
+  ILoveYou: G.ILoveYou,
+  None: G.None
+}, tn = 15;
+class sn extends J {
+  constructor() {
+    super();
+    d(this, "landmarker", null);
+    d(this, "processingTime", null);
+    d(this, "coordinates");
+    d(this, "gesture");
+    d(this, "sourceCanvas");
+    d(this, "downscaler", new de(Js));
+  }
+  async getGestureData() {
+    var l, h;
+    if (!this.landmarker || !this.sourceCanvas)
+      return;
+    const e = this.downscaler.draw(this.sourceCanvas), n = performance.now(), r = this.landmarker.recognizeForVideo(e, n), a = performance.now();
+    this.processingTime = a - n, this.recordInference(n, a), this.recordDetections(r.landmarks.length, ((h = (l = r.gestures[0]) == null ? void 0 : l[0]) == null ? void 0 : h.score) ?? null);
+    const o = r.landmarks[0], c = [];
+    if (o) {
+      const f = r.gestures[0][0].categoryName;
+      return o.forEach((u) => {
+        c.push(le(u));
+      }), {
+        coordinates: c,
+        gesture: en[f]
+      };
+    }
+    return { coordinates: void 0, gesture: void 0 };
+  }
+  async processGestureTracking() {
+    if (!this.disposed) {
+      if (this.shouldRunInference()) {
+        const e = await this.getGestureData();
+        e && (this.coordinates = e.coordinates, this.gesture = e.gesture);
+      }
+      this.disposed || this.paused || (this.rafId = requestAnimationFrame(this.processGestureTracking.bind(this)));
+    }
+  }
+  resume() {
+    this.paused && (super.resume(), this.processGestureTracking());
+  }
+  dispose() {
+    if (super.dispose(), this.landmarker) {
+      try {
+        this.landmarker.close();
+      } catch {
+      }
+      this.landmarker = null;
+    }
+    this.sourceCanvas = void 0, this.downscaler.dispose(), this.coordinates = void 0, this.gesture = void 0;
+  }
+  async initialize() {
+    const e = await j.forVisionTasks(
+      new URL("/assets/xr/wasm", U.assetStorageEndpoint).toString()
+    ), [n] = await Promise.all([
+      Z(
+        new URL(
+          "/assets/xr/models/gesture_tracking.task",
+          U.assetStorageEndpoint
+        ).toString()
+      ),
+      $(e)
+    ]), r = await ds.createFromOptions(e, {
+      baseOptions: {
+        modelAssetBuffer: n,
+        delegate: "GPU"
+      },
+      runningMode: "VIDEO",
+      numHands: 1
+    });
+    this.landmarker = r;
+  }
+  async run({ sourceCanvas: e, targetFps: n, analysisScale: r }) {
+    this.setAnalysisScale(r), this.downscaler.setScale(this.analysisScale), this.sourceCanvas = e, this.setTargetFps(n ?? tn), this.rafId === null && await this.processGestureTracking();
+  }
+  getModelNode() {
+    const e = this;
+    return {
+      get coordinates() {
+        return e.coordinates;
+      },
+      get gesture() {
+        return e.gesture;
+      }
+    };
+  }
+  async getPerformanceData() {
+    return {
+      name: this.constructor.name,
+      processingTime: this.processingTime
+    };
+  }
+}
+class nn extends J {
+  constructor() {
+    super();
+    d(this, "landmarker", null);
+    d(this, "status", "loading");
+    d(this, "error", null);
+    d(this, "processingTime", null);
+    d(this, "sourceCanvas");
+    d(this, "getSource");
+    d(this, "downscaler", new de(Pe().analysisMaxDimension));
+    d(this, "raw");
+    d(this, "delegatePolicy", "auto");
+    d(this, "delegate", "GPU");
+    /** Kept so the graph can be rebuilt on another delegate without refetching. */
+    d(this, "vision", null);
+    d(this, "modelBuffer", null);
+    d(this, "graphOptions", {});
+    d(this, "rebuilding", !1);
+    d(this, "fallbackAttempted", !1);
+    d(this, "result", Ss());
+    d(this, "builder", new ks());
+    d(this, "node");
+    this.node = {
+      getResult: () => this.result,
+      getRawResult: () => this.raw,
+      getStatus: () => this.status,
+      getError: () => this.error,
+      getDelegate: () => this.delegate,
+      setOptions: (e) => this.setRuntimeOptions(e)
+    };
+  }
+  setRuntimeOptions(e) {
+    const n = this.builder.getOptions().analysisMaxDimension;
+    this.builder.setOptions(e);
+    const r = this.builder.getOptions().analysisMaxDimension;
+    r !== n && (this.downscaler.dispose(), this.downscaler = new de(r), this.downscaler.setScale(this.analysisScale));
+  }
+  async initialize(e) {
+    this.status = "loading", this.error = null, this.setRuntimeOptions(e ?? {});
+    try {
+      const n = await j.forVisionTasks(
+        new URL("/assets/xr/wasm", U.assetStorageEndpoint).toString()
+      ), [r] = await Promise.all([
+        Z((e == null ? void 0 : e.modelUrl) ?? gt),
+        $(n)
+      ]);
+      this.vision = n, this.modelBuffer = r, this.graphOptions = {
+        runningMode: "VIDEO",
+        outputFaceBlendshapes: (e == null ? void 0 : e.outputFaceBlendshapes) ?? !0,
+        minFaceDetectionConfidence: e == null ? void 0 : e.minFaceDetectionConfidence,
+        minFacePresenceConfidence: e == null ? void 0 : e.minFacePresenceConfidence,
+        minPoseDetectionConfidence: e == null ? void 0 : e.minPoseDetectionConfidence,
+        minPosePresenceConfidence: e == null ? void 0 : e.minPosePresenceConfidence,
+        minHandLandmarksConfidence: e == null ? void 0 : e.minHandLandmarksConfidence
+      }, this.delegatePolicy = (e == null ? void 0 : e.delegate) ?? "auto", this.delegate = this.delegatePolicy === "CPU" ? "CPU" : "GPU";
+      const a = await this.createLandmarker(this.delegate);
+      if (this.disposed) {
+        a.close();
+        return;
+      }
+      this.landmarker = a, this.status = "ready";
+    } catch (n) {
+      throw this.status = "error", this.error = n instanceof Error ? n : new Error(String(n)), this.error;
+    }
+  }
+  createLandmarker(e) {
+    if (!this.vision || !this.modelBuffer)
+      throw new Error("HolisticTrackingModel: initialize() has not loaded the model");
+    return us.createFromOptions(this.vision, {
+      baseOptions: { modelAssetBuffer: this.modelBuffer, delegate: e },
+      ...this.graphOptions
+    });
+  }
+  /**
+   * The GPU graph can fail on its first run (the face-blendshape stage has no
+   * WebGL kernel for one of its ops). Rebuild on the CPU once, keep the RAF
+   * loop alive meanwhile, and run one detection right away so static sources
+   * (which pulse models once) still get a result.
+   */
+  async fallbackToCpu(e) {
+    this.fallbackAttempted = !0, this.rebuilding = !0, this.status = "loading", console.warn(
+      "[xr-sdk holistic] GPU inference failed; rebuilding the graph on the CPU delegate.",
+      e.message
+    );
+    const n = this.landmarker;
+    try {
+      const r = await this.createLandmarker("CPU");
+      if (this.disposed) {
+        r.close();
+        return;
+      }
+      this.landmarker = r, this.delegate = "CPU", this.status = "ready", this.error = null;
+      try {
+        n == null || n.close();
+      } catch {
+      }
+      this.rebuilding = !1, this.detectOnce();
+    } catch (r) {
+      this.rebuilding = !1, this.status = "error", this.error = r instanceof Error ? r : new Error(String(r));
+    }
+  }
+  /** One detect + publish outside the loop (used after a delegate rebuild). */
+  detectOnce() {
+    this.disposed || !this.landmarker || !this.sourceCanvas || (this.detect(), this.builder.update(this.raw, performance.now(), this.result, this.isMirrored()));
+  }
+  detect() {
+    var r, a, o, c, l;
+    if (!this.landmarker || !this.sourceCanvas) return;
+    const e = this.downscaler.draw(this.sourceCanvas), n = performance.now();
+    try {
+      this.raw = this.landmarker.detectForVideo(e, n), this.status === "error" && (this.status = "ready", this.error = null), this.recordInferenceError(null);
+      const h = this.raw, f = ((r = h.faceLandmarks) != null && r.length ? 1 : 0) + ((a = h.leftHandLandmarks) != null && a.length ? 1 : 0) + ((o = h.rightHandLandmarks) != null && o.length ? 1 : 0) + ((c = h.poseLandmarks) != null && c.length ? 1 : 0), u = (l = h.poseLandmarks) == null ? void 0 : l[0];
+      this.recordDetections(
+        f,
+        u && u.length ? u.reduce((w, S) => w + (S.visibility ?? 0), 0) / u.length : null
+      );
+    } catch (h) {
+      const f = h instanceof Error ? h : new Error(String(h));
+      this.delegatePolicy === "auto" && this.delegate === "GPU" && !this.fallbackAttempted ? this.fallbackToCpu(f) : (this.status = "error", this.error = f, this.recordInferenceError(f));
+    }
+    this.processingTime = performance.now() - n, this.recordInference(n);
+  }
+  /** The session mirrors only the webcam feed (an unknown kind is treated as webcam). */
+  isMirrored() {
+    var e;
+    return He((e = this.getSource) == null ? void 0 : e.call(this));
+  }
+  async run({
+    sourceCanvas: e,
+    getSource: n,
+    targetFps: r,
+    analysisScale: a
+  }) {
+    this.sourceCanvas = e, this.getSource = n, this.setTargetFps(r), this.setAnalysisScale(a), this.downscaler.setScale(this.analysisScale), this.rafId === null && await this.process();
+  }
+  async process() {
+    this.disposed || this.paused || !this.landmarker || (!this.rebuilding && this.shouldRunInference() && this.detect(), this.builder.update(this.raw, performance.now(), this.result, this.isMirrored()), !(this.disposed || this.paused) && (this.rafId = requestAnimationFrame(this.process.bind(this))));
+  }
+  resume() {
+    this.paused && (super.resume(), this.process());
+  }
+  dispose() {
+    if (super.dispose(), this.landmarker) {
+      try {
+        this.landmarker.close();
+      } catch {
+      }
+      this.landmarker = null;
+    }
+    this.sourceCanvas = void 0, this.getSource = void 0, this.downscaler.dispose(), this.vision = null, this.modelBuffer = null, this.raw = void 0, this.builder.reset(), this.result.face = null, this.result.leftHand = null, this.result.rightHand = null, this.result.pose = null;
+  }
+  getModelNode() {
+    return this.node;
+  }
+  async getPerformanceData() {
+    return { name: this.constructor.name, processingTime: this.processingTime };
+  }
+}
+const rn = 512;
+class an extends J {
+  constructor() {
+    super();
+    d(this, "landmarker", null);
+    d(this, "processingTime", null);
+    d(this, "hands");
+    d(this, "coordinates");
+    d(this, "gesture");
+    d(this, "handedness");
+    d(this, "sourceCanvas");
+    d(this, "downscaler", new de(rn));
+  }
+  async getHandData() {
+    var h, f;
+    if (!this.landmarker || !this.sourceCanvas)
+      return;
+    const e = this.downscaler.draw(this.sourceCanvas), n = performance.now(), r = this.landmarker.detectForVideo(e, n), a = performance.now();
+    this.processingTime = a - n, this.recordInference(n, a);
+    const o = [], c = r.handedness ?? r.handednesses ?? [];
+    if (this.recordDetections(r.landmarks.length, ((f = (h = c[0]) == null ? void 0 : h[0]) == null ? void 0 : f.score) ?? null), r.landmarks.forEach((u, w) => {
+      var _, g, v;
+      if (!u || u.length === 0)
+        return;
+      const S = u.map(
+        (y) => le(y)
+      ), k = (v = (g = (_ = c[w]) == null ? void 0 : _[0]) == null ? void 0 : g.categoryName) == null ? void 0 : v.toLowerCase(), x = k === "left" || k === "right" ? k : void 0, T = u[0].z < 0 ? "closed_fist" : "open_palm";
+      o.push({ coordinates: S, gesture: T, handedness: x });
+    }), !o.length)
+      return {
+        hands: void 0,
+        coordinates: void 0,
+        gesture: void 0,
+        handedness: void 0
+      };
+    const l = o[0];
+    return {
+      hands: o,
+      coordinates: l.coordinates,
+      gesture: l.gesture,
+      handedness: l.handedness
+    };
+  }
+  async processHandTracking() {
+    if (!this.disposed) {
+      if (this.shouldRunInference()) {
+        const e = await this.getHandData();
+        e && (this.hands = e.hands, this.coordinates = e.coordinates, this.gesture = e.gesture, this.handedness = e.handedness);
+      }
+      this.disposed || this.paused || (this.rafId = requestAnimationFrame(this.processHandTracking.bind(this)));
+    }
+  }
+  resume() {
+    this.paused && (super.resume(), this.processHandTracking());
+  }
+  dispose() {
+    if (super.dispose(), this.landmarker) {
+      try {
+        this.landmarker.close();
+      } catch {
+      }
+      this.landmarker = null;
+    }
+    this.sourceCanvas = void 0, this.hands = void 0, this.downscaler.dispose(), this.coordinates = void 0, this.gesture = void 0, this.handedness = void 0;
+  }
+  async initialize() {
+    const e = await j.forVisionTasks(
+      new URL("/assets/xr/wasm", U.assetStorageEndpoint).toString()
+    ), [n] = await Promise.all([
+      Z(
+        new URL("/assets/xr/models/hand_tracking.task", U.assetStorageEndpoint).toString()
+      ),
+      $(e)
+    ]), r = await hs.createFromOptions(e, {
+      baseOptions: {
+        modelAssetBuffer: n,
+        delegate: "GPU"
+      },
+      runningMode: "VIDEO",
+      numHands: 2
+    });
+    this.landmarker = r;
+  }
+  async run({ sourceCanvas: e, targetFps: n, analysisScale: r }) {
+    this.setAnalysisScale(r), this.downscaler.setScale(this.analysisScale), this.sourceCanvas = e, this.setTargetFps(n), this.rafId === null && await this.processHandTracking();
+  }
+  getModelNode() {
+    const e = this;
+    return {
+      get hands() {
+        return e.hands;
+      },
+      get coordinates() {
+        return e.coordinates;
+      },
+      get gesture() {
+        return e.gesture;
+      },
+      get handedness() {
+        return e.handedness;
+      }
+    };
+  }
+  async getPerformanceData() {
+    return {
+      name: this.constructor.name,
+      processingTime: this.processingTime
+    };
+  }
+}
+const on = 24, cn = 720, ln = [
+  [255, 255, 255, 255],
+  // 0: background → green 255, kept
+  [0, 0, 0, 0]
+  // 1: person → green 0, discarded
+];
+class dn extends J {
+  constructor() {
+    super();
+    d(this, "segmenter", null);
+    d(this, "processingTime", null);
+    d(this, "sourceCanvas");
+    // input source canvas
+    d(this, "processCanvas");
+    // downscaled canvas of sourceCanvas for processing
+    d(this, "filterCanvas");
+    // post-processing (blur) canvas
+    // Optional high-resolution input override. The shared session feed canvas is
+    // sized to the on-screen display layout (often a small, display-fit crop),
+    // which starves the segmenter of the resolution it needs to capture the whole
+    // body. When a consumer supplies a native-resolution source here (e.g. the raw
+    // <video>/<img>), the segmenter runs on THAT instead — letterboxed into the
+    // process canvas so nothing is cropped. Falls back to `sourceCanvas` when unset.
+    d(this, "inputSource");
+    d(this, "inputSourceSize");
+    // The segmenter's own WebGL2 context. DrawingUtils renders the inverted mask
+    // into this context on the GPU; we then blit that GL canvas straight into the
+    // mask canvas with a single `drawImage` — a GPU→GPU transfer, no CPU readback
+    // and no per-pixel JS loop. (A spike proved `drawImage(glCanvas)` reads the
+    // full DrawingUtils output correctly; the earlier "reads empty" wall that once
+    // forced a readPixels path was a false alarm.)
+    d(this, "glCanvas");
+    d(this, "drawingUtils");
+    d(this, "useGpuMaskPath", !1);
+    // CPU-fallback reused ImageData, allocated on size change only. Used ONLY when
+    // WebGL2 is unavailable and we must read the single-channel mask back by hand.
+    d(this, "maskImageData");
+    d(this, "maskCanvas", null);
+    d(this, "segmentationMaskTexture");
+    d(this, "isMaskSetup", !1);
+    d(this, "isProcessing", !1);
+    // Live clone of the most recent category mask, kept so getRawSegmentationData()
+    // can read the single-channel Uint8Array lazily — that readback is paid ONLY
+    // when a consumer actually asks for raw data. Cloned because the mask returned
+    // by segmentForVideo is invalidated on the next inference call.
+    d(this, "latestMask", null);
+    // Per-frame cache of the read-back array, so repeated getRawSegmentationData()
+    // calls within one frame don't re-run the GPU→CPU transfer.
+    d(this, "rawCache", null);
+    d(this, "quality", "medium");
+    d(this, "stagingCanvas");
+  }
+  getQualityScaleFactor() {
+    switch (this.quality) {
+      case "low":
+        return 0.5;
+      case "medium":
+        return 0.75;
+      case "high":
+        return 1;
+      default:
+        return 0.5;
+    }
+  }
+  /**
+   * Set (or clear) a high-resolution input override. Pass the raw <video>/<img>
+   * (or any CanvasImageSource with intrinsic dimensions) to run segmentation on
+   * native-resolution, uncropped frames instead of the small display-fit session
+   * feed. Pass `undefined` to revert to the shared feed canvas.
+   */
+  setInputSource(e) {
+    this.inputSource = e, this.inputSourceSize = e ? this.readIntrinsicSize(e) : void 0;
+  }
+  readIntrinsicSize(e) {
+    if (e instanceof HTMLVideoElement)
+      return e.videoWidth > 0 ? { width: e.videoWidth, height: e.videoHeight } : void 0;
+    if (e instanceof HTMLImageElement)
+      return e.naturalWidth > 0 ? { width: e.naturalWidth, height: e.naturalHeight } : void 0;
+    const n = e.width, r = e.height;
+    return typeof n == "number" && n > 0 && typeof r == "number" && r > 0 ? { width: n, height: r } : void 0;
+  }
+  /**
+   * Size the process canvas to the override input's aspect ratio, bounded by
+   * PROCESS_MAX_DIM on the long edge, and keep the GL canvas in sync so the GPU
+   * mask renders at the same resolution. No-op when there is no override, or when
+   * the intrinsic size hasn't changed since the last frame.
+   */
+  ensureProcessCanvasForInput() {
+    if (!this.processCanvas || !this.inputSource) return;
+    const e = this.readIntrinsicSize(this.inputSource);
+    if (!e) return;
+    this.inputSourceSize = e;
+    const n = Math.min(1, cn / Math.max(e.width, e.height)), r = Math.max(1, Math.round(e.width * n)), a = Math.max(1, Math.round(e.height * n));
+    this.processCanvas.width === r && this.processCanvas.height === a || (this.processCanvas.width = r, this.processCanvas.height = a, this.glCanvas && (this.glCanvas.width = r, this.glCanvas.height = a), this.maskImageData = void 0);
+  }
+  async processSegmentation() {
+    if (this.disposed || !this.isProcessing || !this.maskCanvas || !this.processCanvas)
+      return;
+    if (!this.shouldRunInference()) {
+      if (this.disposed || this.paused) return;
+      this.rafId = requestAnimationFrame(this.processSegmentation.bind(this));
+      return;
+    }
+    const e = this.inputSource ?? this.sourceCanvas;
+    if (!this.segmenter || !e) {
+      if (this.disposed || this.paused) return;
+      this.rafId = requestAnimationFrame(this.processSegmentation.bind(this));
+      return;
+    }
+    const n = performance.now();
+    this.ensureProcessCanvasForInput();
+    const r = this.processCanvas.getContext("2d");
+    if (r) {
+      const c = this.processCanvas.width, l = this.processCanvas.height;
+      if (r.clearRect(0, 0, c, l), this.inputSource && this.inputSourceSize) {
+        const { width: h, height: f } = this.inputSourceSize, u = Math.min(c / h, l / f), w = h * u, S = f * u;
+        r.drawImage(this.inputSource, (c - w) / 2, (l - S) / 2, w, S);
+      } else
+        r.drawImage(e, 0, 0, c, l);
+    }
+    const o = this.segmenter.segmentForVideo(
+      this.processCanvas,
+      performance.now()
+    ).categoryMask;
+    if (!o) {
+      if (this.disposed || this.paused) return;
+      this.rafId = requestAnimationFrame(this.processSegmentation.bind(this));
+      return;
+    }
+    if (this.rawCache = null, this.latestMask && (this.latestMask.close(), this.latestMask = null), this.useGpuMaskPath && this.drawingUtils && this.glCanvas)
+      this.drawingUtils.drawCategoryMask(o, ln), this.latestMask = o.clone(), o.close(), this.blitGlToMask();
+    else {
+      this.latestMask = o.clone();
+      const c = this.readMaskToImageData(o);
+      o.close(), c && this.blitImageDataToMask(c);
+    }
+    this.segmentationMaskTexture && (this.isMaskSetup || (this.segmentationMaskTexture.format = mt, this.segmentationMaskTexture.minFilter = pe, this.segmentationMaskTexture.magFilter = pe, this.segmentationMaskTexture.generateMipmaps = !1, this.isMaskSetup = !0), this.segmentationMaskTexture.needsUpdate = !0), this.processingTime = performance.now() - n, this.recordInference(n), this.recordDetections(1, null), !(this.disposed || this.paused) && (this.rafId = requestAnimationFrame(this.processSegmentation.bind(this)));
+  }
+  /**
+   * Blit the GPU-rendered mask (already RGBA-inverted by drawCategoryMask)
+   * straight from the GL canvas into the mask canvas, cover-fitted through the
+   * soft-edge blur. `drawImage(glCanvas)` is a GPU→GPU transfer — no readPixels,
+   * no CPU array, no ImageData, no row flip (the 2D canvas presents the WebGL
+   * canvas right-side-up). This is the zero-readback path.
+   */
+  blitGlToMask() {
+    if (!this.maskCanvas || !this.filterCanvas || !this.glCanvas) return;
+    const e = this.maskCanvas.getContext("2d"), n = this.filterCanvas.getContext("2d");
+    !e || !n || (n.filter = "blur(0.5px)", n.clearRect(0, 0, this.filterCanvas.width, this.filterCanvas.height), n.drawImage(this.glCanvas, 0, 0, this.filterCanvas.width, this.filterCanvas.height), e.clearRect(0, 0, this.maskCanvas.width, this.maskCanvas.height), e.drawImage(this.filterCanvas, 0, 0, this.maskCanvas.width, this.maskCanvas.height));
+  }
+  /**
+   * CPU-fallback inverted-alpha ImageData build (only when the GPU path is off).
+   * The single-channel mask is expanded to RGBA with the person→transparent,
+   * background→opaque convention (green carries the signal for the alphaMap).
+   */
+  readMaskToImageData(e) {
+    const n = e.getAsUint8Array(), { width: r, height: a } = e;
+    if (!n || r <= 0 || a <= 0) return null;
+    (!this.maskImageData || this.maskImageData.width !== r || this.maskImageData.height !== a) && (this.maskImageData = new ImageData(r, a));
+    const o = this.maskImageData.data;
+    for (let c = 0; c < n.length; c += 1) {
+      const l = n[c] === 255 ? 0 : 255;
+      o[c * 4] = 255, o[c * 4 + 1] = l, o[c * 4 + 2] = 255, o[c * 4 + 3] = l;
+    }
+    return this.maskImageData;
+  }
+  /**
+   * CPU-fallback blit: put the inverted-alpha mask ImageData into maskCanvas
+   * with a soft-edge blur, cover-fitted to the render target. Only used when the
+   * GPU path is off; the GPU path blits the GL canvas directly (blitGlToMask).
+   */
+  blitImageDataToMask(e) {
+    if (!this.maskCanvas || !this.filterCanvas) return;
+    const n = this.maskCanvas.getContext("2d"), r = this.filterCanvas.getContext("2d");
+    if (!n || !r) return;
+    const a = this.getStagingCanvas(e.width, e.height), o = a.getContext("2d");
+    o && (o.putImageData(e, 0, 0), r.filter = "blur(0.5px)", r.clearRect(0, 0, this.filterCanvas.width, this.filterCanvas.height), r.drawImage(a, 0, 0, this.filterCanvas.width, this.filterCanvas.height), n.clearRect(0, 0, this.maskCanvas.width, this.maskCanvas.height), n.drawImage(this.filterCanvas, 0, 0, this.maskCanvas.width, this.maskCanvas.height));
+  }
+  getStagingCanvas(e, n) {
+    return this.stagingCanvas || (this.stagingCanvas = document.createElement("canvas")), this.stagingCanvas.width !== e && (this.stagingCanvas.width = e), this.stagingCanvas.height !== n && (this.stagingCanvas.height = n), this.stagingCanvas;
+  }
+  resume() {
+    this.paused && (super.resume(), this.processSegmentation());
+  }
+  dispose() {
+    if (super.dispose(), this.isProcessing = !1, this.latestMask) {
+      try {
+        this.latestMask.close();
+      } catch {
+      }
+      this.latestMask = null;
+    }
+    if (this.rawCache = null, this.segmenter) {
+      try {
+        this.segmenter.close();
+      } catch {
+      }
+      this.segmenter = null;
+    }
+    this.drawingUtils = void 0, this.glCanvas = void 0, this.maskImageData = void 0, this.segmentationMaskTexture && (this.segmentationMaskTexture.dispose(), this.segmentationMaskTexture = void 0), this.sourceCanvas = void 0, this.inputSource = void 0, this.inputSourceSize = void 0, this.processCanvas = void 0, this.filterCanvas = void 0, this.stagingCanvas = void 0, this.maskCanvas = null;
+  }
+  async initialize(e) {
+    this.quality = (e == null ? void 0 : e.quality) ?? "low";
+    const n = await j.forVisionTasks(
+      new URL("/assets/xr/wasm", U.assetStorageEndpoint).toString()
+    ), [r] = await Promise.all([
+      Z(
+        new URL("/assets/xr/models/segmentation.tflite", U.assetStorageEndpoint).toString()
+      ),
+      $(n)
+    ]);
+    this.glCanvas = new OffscreenCanvas(1, 1);
+    const a = this.glCanvas.getContext("webgl2", {
+      preserveDrawingBuffer: !0
+    });
+    this.segmenter = await ht.createFromOptions(n, {
+      baseOptions: {
+        modelAssetBuffer: r,
+        delegate: "GPU"
+      },
+      ...a ? { canvas: this.glCanvas } : {},
+      outputCategoryMask: !0,
+      outputConfidenceMasks: !1,
+      runningMode: "VIDEO"
+    }), a ? (this.drawingUtils = new ms(a), this.useGpuMaskPath = !0) : this.useGpuMaskPath = !1;
+  }
+  async run({
+    sourceCanvas: e,
+    renderWidth: n,
+    renderHeight: r,
+    targetFps: a
+  }) {
+    var c;
+    if (!e)
+      return;
+    this.setTargetFps(a ?? on), this.isProcessing = !1, this.rafId !== null && (cancelAnimationFrame(this.rafId), this.rafId = null);
+    const o = this.getQualityScaleFactor();
+    this.sourceCanvas = e, this.processCanvas = document.createElement("canvas"), this.processCanvas.width = e.width * o, this.processCanvas.height = e.height * o, this.glCanvas && (this.glCanvas.width = this.processCanvas.width, this.glCanvas.height = this.processCanvas.height), this.maskImageData = void 0, this.maskCanvas = document.createElement("canvas"), this.maskCanvas.width = n, this.maskCanvas.height = r, this.filterCanvas = document.createElement("canvas"), this.filterCanvas.width = n, this.filterCanvas.height = r, (c = this.segmentationMaskTexture) == null || c.dispose(), this.segmentationMaskTexture = new ft(this.maskCanvas), this.isMaskSetup = !1, this.rawCache = null, this.isProcessing = !0, this.lastInferenceMs = 0, this.rafId = requestAnimationFrame(this.processSegmentation.bind(this));
+  }
+  /**
+   * Lazily read the single-channel mask back to a Uint8Array. Only invoked when
+   * a consumer calls getRawSegmentationData(); the default texture path never
+   * touches it, so apps that only use <VideoBackground> pay no extra readback.
+   */
+  getRawSegmentationData() {
+    if (this.rawCache) return this.rawCache;
+    if (!this.latestMask) return null;
+    const e = this.latestMask.getAsUint8Array();
+    return this.rawCache = {
+      maskData: e,
+      width: this.latestMask.width,
+      height: this.latestMask.height
+    }, this.rawCache;
+  }
+  getModelNode() {
+    const e = this;
+    return {
+      get backgroundSegmentationMask() {
+        return e.segmentationMaskTexture;
+      },
+      getMaskCanvas: () => e.maskCanvas,
+      getRawSegmentationData: () => e.getRawSegmentationData(),
+      setInputSource: (n) => e.setInputSource(n ?? void 0)
+    };
+  }
+  async getPerformanceData() {
+    return {
+      name: this.constructor.name,
+      processingTime: this.processingTime
+    };
+  }
+}
+const un = (t, s, e, n = "feed") => ({
+  width: Math.max(1, Math.round(t)),
+  height: Math.max(1, Math.round(s)),
+  indices: new Uint8Array(Math.max(1, Math.round(t)) * Math.max(1, Math.round(s))),
+  labels: e,
+  space: n,
+  version: 0
+}), ur = (t) => {
+  t.indices.fill(0);
+}, hr = (t, s) => t.labels.indexOf(s), hn = (t, s, e) => {
+  const { width: n, height: r, indices: a } = t, o = s.length;
+  if (o < 3) return;
+  let c = 1 / 0, l = -1 / 0;
+  for (let w = 0; w < o; w += 1) {
+    const S = s[w].y * r;
+    S < c && (c = S), S > l && (l = S);
+  }
+  const h = Math.max(0, Math.floor(c)), f = Math.min(r - 1, Math.ceil(l)), u = [];
+  for (let w = h; w <= f; w += 1) {
+    const S = w + 0.5;
+    u.length = 0;
+    for (let x = 0; x < o; x += 1) {
+      const T = s[x], _ = s[(x + 1) % o], g = T.y * r, v = _.y * r;
+      if (S < g == S < v) continue;
+      const y = (S - g) / (v - g);
+      u.push((T.x + y * (_.x - T.x)) * n);
+    }
+    u.sort((x, T) => x - T);
+    const k = w * n;
+    for (let x = 0; x + 1 < u.length; x += 2) {
+      const T = Math.max(0, Math.round(u[x])), _ = Math.min(n, Math.round(u[x + 1]));
+      for (let g = T; g < _; g += 1) a[k + g] = e;
+    }
+  }
+}, mr = (t, s, e, n, r = []) => {
+  r.length = 0;
+  for (let a = 0; a < e.length; a += 1) {
+    const o = s[e[a]];
+    if (!o) return;
+    r.push(o);
+  }
+  hn(t, r, n);
+}, it = (t) => t, ot = {
+  hair: {
+    labels: ["bg", "hair"],
+    assetPath: "/assets/xr/models/hair_segmenter.tflite",
+    defaultUrl: "https://storage.googleapis.com/mediapipe-models/image_segmenter/hair_segmenter/float32/latest/hair_segmenter.tflite",
+    decode: it
+  },
+  multiclass: {
+    labels: ["bg", "hair", "body_skin", "face_skin", "clothes", "others"],
+    assetPath: "/assets/xr/models/selfie_multiclass_256x256.tflite",
+    defaultUrl: "https://storage.googleapis.com/mediapipe-models/image_segmenter/selfie_multiclass_256x256/float32/latest/selfie_multiclass_256x256.tflite",
+    decode: it
+  }
+}, mn = (t, s, e) => {
+  const n = e.length === t.length ? e : new Uint8Array(t.length);
+  for (let r = 0; r < t.length; r += 1) n[r] = s(t[r]);
+  return n;
+}, fn = 15, gn = { low: 0.5, medium: 0.75, high: 1 };
+class pn extends J {
+  constructor() {
+    super();
+    d(this, "segmenter", null);
+    d(this, "preset", "hair");
+    d(this, "quality", "medium");
+    d(this, "status", "loading");
+    d(this, "error", null);
+    d(this, "processingTime", null);
+    d(this, "sourceCanvas");
+    d(this, "processCanvas");
+    d(this, "isProcessing", !1);
+    d(this, "mask", un(1, 1, ["bg"]));
+    d(this, "node");
+    this.node = {
+      getMask: () => this.mask,
+      getStatus: () => this.status,
+      getError: () => this.error
+    };
+  }
+  async initialize(e) {
+    this.preset = (e == null ? void 0 : e.preset) ?? "hair", this.quality = (e == null ? void 0 : e.quality) ?? "medium";
+    const n = ot[this.preset];
+    this.mask.labels = n.labels, this.status = "loading", this.error = null;
+    try {
+      const r = await j.forVisionTasks(
+        new URL("/assets/xr/wasm", U.assetStorageEndpoint).toString()
+      ), a = (e == null ? void 0 : e.modelUrl) ?? n.defaultUrl, [o] = await Promise.all([
+        Z(a),
+        $(r)
+      ]);
+      this.segmenter = await ht.createFromOptions(r, {
+        baseOptions: { modelAssetBuffer: o, delegate: "GPU" },
+        outputCategoryMask: !0,
+        outputConfidenceMasks: !1,
+        runningMode: "VIDEO"
+      }), this.status = "ready";
+    } catch (r) {
+      throw this.status = "error", this.error = r instanceof Error ? r : new Error(String(r)), this.error;
+    }
+  }
+  async run({ sourceCanvas: e, targetFps: n }) {
+    e && (this.setTargetFps(n ?? fn), this.isProcessing = !1, this.rafId !== null && (cancelAnimationFrame(this.rafId), this.rafId = null), this.sourceCanvas = e, this.processCanvas = document.createElement("canvas"), this.isProcessing = !0, this.lastInferenceMs = 0, this.rafId = requestAnimationFrame(this.process.bind(this)));
+  }
+  process() {
+    if (this.disposed || this.paused || !this.isProcessing) return;
+    const { segmenter: e, sourceCanvas: n, processCanvas: r } = this;
+    if (!e || !n || !r || !this.shouldRunInference()) {
+      this.rafId = requestAnimationFrame(this.process.bind(this));
+      return;
+    }
+    const a = performance.now(), o = gn[this.quality], c = Math.max(1, Math.round(n.width * o)), l = Math.max(1, Math.round(n.height * o));
+    (r.width !== c || r.height !== l) && (r.width = c, r.height = l);
+    const h = r.getContext("2d");
+    h && h.drawImage(n, 0, 0, c, l);
+    try {
+      const u = e.segmentForVideo(r, performance.now()).categoryMask;
+      if (u) {
+        const w = u.getAsUint8Array();
+        (this.mask.width !== u.width || this.mask.height !== u.height) && (this.mask.width = u.width, this.mask.height = u.height), this.mask.indices = mn(
+          w,
+          ot[this.preset].decode,
+          this.mask.indices
+        ), this.mask.version += 1, u.close();
+      }
+      this.status === "error" && (this.status = "ready", this.error = null), this.recordInferenceError(null), this.recordDetections(u ? 1 : 0, null);
+    } catch (f) {
+      this.status = "error", this.error = f instanceof Error ? f : new Error(String(f)), this.recordInferenceError(this.error);
+    }
+    this.processingTime = performance.now() - a, this.recordInference(a), !(this.disposed || this.paused) && (this.rafId = requestAnimationFrame(this.process.bind(this)));
+  }
+  resume() {
+    this.paused && (super.resume(), this.isProcessing && (this.rafId = requestAnimationFrame(this.process.bind(this))));
+  }
+  getModelNode() {
+    return this.node;
+  }
+  async getPerformanceData() {
+    return { name: this.constructor.name, processingTime: this.processingTime };
+  }
+  dispose() {
+    var e;
+    super.dispose(), this.isProcessing = !1;
+    try {
+      (e = this.segmenter) == null || e.close();
+    } catch {
+    }
+    this.segmenter = null, this.sourceCanvas = void 0, this.processCanvas = void 0;
+  }
+}
+const ct = {
+  [R.BACKGROUND_SEGMENTATION]: dn,
+  [R.SEMANTIC_SEGMENTATION]: pn,
+  [R.HAND_TRACKER]: an,
+  [R.GESTURE_TRACKER]: sn,
+  [R.FACE_TRACKER]: Zs,
+  [R.BODY_TRACKER]: Xs,
+  [R.HOLISTIC_TRACKER]: nn
+}, yn = async (t) => {
+  const s = document.createElement("video");
+  s.srcObject = t, s.muted = !0, s.playsInline = !0, s.autoplay = !0, await new Promise((n) => {
+    s.onloadedmetadata = () => {
+      s.play(), n();
+    };
+  });
+  const e = s;
+  return await new Promise((n) => {
+    const r = setTimeout(n, 150), a = () => {
+      clearTimeout(r), n();
+    };
+    typeof e.requestVideoFrameCallback == "function" ? e.requestVideoFrameCallback(a) : requestAnimationFrame(() => requestAnimationFrame(() => a()));
+  }), s;
+}, wn = (t) => {
+  const s = new ft(t);
+  return s.colorSpace = fs, s.format = mt, s.minFilter = pe, s.magFilter = pe, s.generateMipmaps = !1, s.needsUpdate = !0, s;
+}, vn = (t, s) => {
+  const e = t.videoWidth, n = t.videoHeight;
+  e > 0 && n > 0 && (s.width !== e && (s.width = e), s.height !== n && (s.height = n));
+  const r = s.getContext("2d", {
+    colorSpace: "srgb"
+  });
+  r.save(), r.scale(-1, 1), r.drawImage(t, -s.width, 0, s.width, s.height), r.restore();
+}, Sn = (t, s, e = 1) => {
+  const n = s.getContext("2d", {
+    colorSpace: "srgb"
+  }), r = Ds({
+    source: { width: t.width, height: t.height },
+    feed: { width: s.width, height: s.height },
+    zoom: e
+  });
+  r && (n.setTransform(1, 0, 0, 1, 0, 0), n.clearRect(0, 0, s.width, s.height), n.drawImage(
+    t,
+    0,
+    0,
+    t.width,
+    t.height,
+    r.offsetX,
+    r.offsetY,
+    r.drawWidth,
+    r.drawHeight
+  ));
+}, Mn = (t, s, e) => {
+  const n = /* @__PURE__ */ new Map(), r = /* @__PURE__ */ new WeakSet();
+  let a = !1;
+  const o = (g, v) => {
+    const y = t.getSnapshot().modelErrors;
+    if (v === null && !y.has(g)) return;
+    const C = new Map(y);
+    v === null ? C.delete(g) : C.set(g, { model: g, error: v, at: performance.now() }), t.set({ modelErrors: C });
+  }, c = (g, v) => {
+    var y;
+    try {
+      (y = v.dispose) == null || y.call(v);
+    } catch (C) {
+      console.warn(`[xr-sdk registry] dispose threw for ${g}`, C);
+    }
+  };
+  return {
+    acquire: async (g, v, y) => {
+      let C = n.get(g);
+      if (C)
+        return C.refs.add(v), C.activeRefs.add(v), C.initPromise;
+      const N = s[g];
+      if (!N)
+        throw new Error(`Invalid model: ${g}`);
+      const E = new N(), V = /* @__PURE__ */ new Set([v]), q = /* @__PURE__ */ new Set([v]);
+      o(g, null);
+      const L = (async () => {
+        await E.initialize(y);
+        const A = n.get(g);
+        if (!A || A.model !== E || A.refs.size === 0)
+          return c(g, E), E;
+        e && await e(g, E);
+        const W = n.get(g);
+        return W && W.refs.size > 0 && (r.add(E), t.setPipeline((K) => K.set(g, E))), E;
+      })();
+      return C = { model: E, refs: V, activeRefs: q, initPromise: L, options: y }, n.set(g, C), L.catch((A) => {
+        n.get(g) === C && (n.delete(g), t.setPipeline((K) => K.delete(g)), o(g, A instanceof Error ? A : new Error(String(A)))), c(g, E);
+      }), L;
+    },
+    release: (g, v) => {
+      const y = n.get(g);
+      y && (y.refs.delete(v), y.activeRefs.delete(v) && y.refs.size > 0 && y.activeRefs.size === 0 && y.model.pause(), !(y.refs.size > 0) && (n.delete(g), c(g, y.model), t.setPipeline((C) => C.delete(g))));
+    },
+    setActive: (g, v, y) => {
+      const C = n.get(g);
+      if (!C || !C.refs.has(v)) return;
+      const N = C.activeRefs.size > 0;
+      y ? C.activeRefs.add(v) : C.activeRefs.delete(v);
+      const E = C.activeRefs.size > 0;
+      N !== E && (E && !a ? C.model.resume() : C.model.pause());
+    },
+    suspendAll: () => {
+      a = !0;
+      for (const g of n.values())
+        g.model.pause();
+    },
+    resumeActive: () => {
+      a = !1;
+      for (const g of n.values())
+        g.activeRefs.size > 0 && g.model.resume();
+    },
+    get: (g) => {
+      var v;
+      return (v = n.get(g)) == null ? void 0 : v.model;
+    },
+    getOptions: (g) => {
+      var v;
+      return (v = n.get(g)) == null ? void 0 : v.options;
+    },
+    releaseAll: () => {
+      for (const g of Array.from(n.keys())) {
+        const v = n.get(g);
+        v && (v.refs.clear(), n.delete(g), c(g, v.model));
+      }
+      t.setPipeline((g) => g.clear());
+    },
+    getState: (g) => {
+      const v = n.get(g);
+      return v ? r.has(v.model) ? "ready" : "initializing" : t.getSnapshot().modelErrors.has(g) ? "error" : "idle";
+    },
+    getOwners: (g) => {
+      const v = n.get(g);
+      return {
+        refs: v ? Array.from(v.refs) : [],
+        active: v ? Array.from(v.activeRefs) : []
+      };
+    }
+  };
+}, kn = {
+  lifecycle: "idle",
+  ready: !1,
+  error: void 0,
+  cameraTexture: void 0,
+  renderWidth: 0,
+  renderHeight: 0,
+  source: void 0,
+  sourceKind: void 0,
+  cameraFacing: null,
+  cameraDeviceId: null,
+  orientation: { type: "portrait", angle: 0 },
+  quality: null,
+  qualityConfig: null,
+  sourceWidth: 0,
+  sourceHeight: 0,
+  cameraZoom: 1.2,
+  pipeline: /* @__PURE__ */ new Map(),
+  modelErrors: /* @__PURE__ */ new Map(),
+  cameraPermission: "unknown",
+  cameraPermissionReason: null,
+  feedFrames: 0
+}, Cn = () => {
+  let t = { ...kn, pipeline: /* @__PURE__ */ new Map(), modelErrors: /* @__PURE__ */ new Map() };
+  const s = /* @__PURE__ */ new Set(), e = () => {
+    s.forEach((n) => n());
+  };
+  return {
+    getSnapshot: () => t,
+    set: (n) => {
+      let r = !1;
+      for (const a of Object.keys(n))
+        if (n[a] !== t[a]) {
+          r = !0;
+          break;
+        }
+      r && (t = { ...t, ...n }, e());
+    },
+    setPipeline: (n) => {
+      const r = new Map(t.pipeline);
+      return n(r), t = { ...t, pipeline: r }, e(), r;
+    },
+    subscribe: (n) => (s.add(n), () => {
+      s.delete(n);
+    })
+  };
+}, lt = (t, s) => s ?? t === "user", xn = ({
+  renderHeight: t,
+  renderWidth: s,
+  videoHeight: e,
+  videoWidth: n
+}) => ({
+  height: t || e,
+  width: s || n
+}), bn = (t, s) => {
+  const e = new Hs({ verbose: !0 }), n = Cn();
+  n.set({ cameraZoom: (t == null ? void 0 : t.cameraZoom) ?? 1.2 });
+  let r = s, a = t;
+  const o = (i) => {
+    var p;
+    const m = (p = z.getOptions(i)) == null ? void 0 : p.targetFps;
+    return typeof m == "number" ? m : a == null ? void 0 : a.targetFps;
+  };
+  let c, l, h, f, u, w, S, k, x, T, _, g, v = !1, y = !1, C = !1, N = 0, E, V, q, L = !1, A = 0, W = /* @__PURE__ */ new WeakSet();
+  const K = /* @__PURE__ */ new Set(), me = (i) => {
+    const m = n.getSnapshot().cameraTexture;
+    m && m.dispose();
+    const p = wn(i);
+    return n.set({ cameraTexture: p }), p;
+  }, we = async (i, m) => {
+    if (W.has(m) || n.getSnapshot().lifecycle !== "running" || !u) return;
+    W.add(m);
+    const p = A;
+    try {
+      await m.run({
+        sourceCanvas: u,
+        renderWidth: n.getSnapshot().renderWidth,
+        renderHeight: n.getSnapshot().renderHeight,
+        getSource: () => n.getSnapshot().sourceKind,
+        targetFps: o(i),
+        analysisScale: a == null ? void 0 : a.analysisScale
+      }), L && (await new Promise((M) => requestAnimationFrame(() => M())), await new Promise((M) => requestAnimationFrame(() => M())), L && A === p && z.suspendAll());
+    } catch (M) {
+      throw W.delete(m), M;
+    }
+  }, z = Mn(n, ct, (i, m) => we(i, m));
+  n.subscribe(() => {
+    if (n.getSnapshot().lifecycle !== "running") return;
+    const i = n.getSnapshot().pipeline;
+    for (const [m, p] of i.entries())
+      W.has(p) || we(m, p);
+  });
+  const Ne = () => {
+    g !== void 0 && (cancelAnimationFrame(g), g = void 0);
+  }, ee = () => {
+    if (Ne(), E == null || E(), E = void 0, l) {
+      try {
+        l.pause();
+      } catch {
+      }
+      try {
+        l.srcObject = null;
+      } catch {
+      }
+      l = void 0;
+    }
+    if (h) {
+      try {
+        h.getTracks().forEach((i) => i.stop());
+      } catch {
+      }
+      h = void 0;
+    }
+  }, ve = () => {
+    if (v || !l || !f || !u) return;
+    const i = typeof window < "u" ? window.__xr_debugger_metrics : void 0;
+    if (i != null && i.trackCameraFrame && i.trackCameraFrame(), He(n.getSnapshot().sourceKind))
+      vn(l, f);
+    else {
+      const b = f.getContext("2d");
+      if (!b) return;
+      const P = l.videoWidth, D = l.videoHeight;
+      f.width !== P && (f.width = P), f.height !== D && (f.height = D), b.setTransform(1, 0, 0, 1, 0, 0), b.clearRect(0, 0, P, D), b.drawImage(l, 0, 0, P, D);
+    }
+    Sn(f, u, (a == null ? void 0 : a.cameraZoom) ?? 1.2);
+    const p = n.getSnapshot();
+    (p.sourceWidth !== l.videoWidth || p.sourceHeight !== l.videoHeight) && n.set({ sourceWidth: l.videoWidth, sourceHeight: l.videoHeight }), N += 1, N % 10 === 0 && n.set({ feedFrames: N });
+    const M = n.getSnapshot().cameraTexture;
+    M && (M.needsUpdate = !0);
+  }, Se = () => {
+    if (!l || !f || !u) return;
+    if (L) {
+      ve();
+      return;
+    }
+    const i = () => {
+      g = requestAnimationFrame(i), ve();
+    };
+    g = requestAnimationFrame(i);
+  }, Rt = async (i, m) => {
+    if (i.source === F.WEBCAM)
+      try {
+        const p = a != null && a.camRes && a.camRes > 0 ? a.camRes : 960;
+        n.set({ cameraPermission: "requesting", cameraPermissionReason: null });
+        const M = i.deviceId ? { deviceId: { exact: i.deviceId } } : { facingMode: { ideal: i.facingMode ?? "user" } }, b = {
+          frameRate: { min: 24, ideal: 30, max: 60 },
+          width: { ideal: p },
+          ...M
+        };
+        let P;
+        try {
+          P = await navigator.mediaDevices.getUserMedia({ video: b });
+        } catch (D) {
+          if (!(D instanceof DOMException && D.name === "OverconstrainedError")) throw D;
+          P = await navigator.mediaDevices.getUserMedia({
+            video: { frameRate: { ideal: 30 }, width: { ideal: p }, ...M }
+          });
+        }
+        return m === A && n.set({ cameraPermission: "granted", cameraPermissionReason: null }), P;
+      } catch (p) {
+        const M = vt(p), b = rt[M], P = await St(), D = Mt(M, P.state);
+        throw m === A && n.set({
+          error: { error: "PermissionError", message: b, reason: M },
+          cameraPermission: D.state,
+          cameraPermissionReason: D.reason
+        }), new O(p instanceof Error ? p.message : "getUserMedia failed");
+      }
+    return i.stream;
+  }, Be = (i) => {
+    const { lifecycle: m } = n.getSnapshot();
+    m === "idle" || m === "stopped" || v || (ee(), z.suspendAll(), A += 1, c = void 0, n.set({
+      lifecycle: "stopped",
+      ready: !1,
+      error: { error: "PermissionError", message: rt[i], reason: i },
+      cameraPermission: i === "permission-denied" ? "blocked" : "unavailable",
+      cameraPermissionReason: wt(i)
+    }), e.log("XR session stopped: camera lost.", i));
+  }, Ft = (i) => {
+    var M;
+    E == null || E();
+    const m = ((M = i.getVideoTracks) == null ? void 0 : M.call(i)) ?? [], p = () => {
+      h === i && Be("camera-lost");
+    };
+    m.forEach((b) => {
+      var P;
+      return (P = b.addEventListener) == null ? void 0 : P.call(b, "ended", p);
+    }), E = () => {
+      m.forEach((b) => {
+        var P;
+        return (P = b.removeEventListener) == null ? void 0 : P.call(b, "ended", p);
+      });
+    };
+  }, It = async () => {
+    if (V || typeof navigator > "u") return;
+    const i = navigator.permissions;
+    if (i != null && i.query)
+      try {
+        const m = await i.query({ name: "camera" });
+        if (y) return;
+        V = m, q = () => {
+          m.state === "denied" && (c == null ? void 0 : c.source) === F.WEBCAM && Be("permission-denied");
+        }, m.addEventListener("change", q);
+      } catch {
+      }
+  }, _t = () => {
+    var i;
+    V && q && ((i = V.removeEventListener) == null || i.call(V, "change", q)), V = void 0, q = void 0;
+  }, Me = async (i) => {
+    var Ze, fe, $e;
+    const m = A, p = await Rt(i, m);
+    if (m !== A)
+      throw p.getTracks().forEach((re) => re.stop()), new O("Media source superseded by a newer bind");
+    h = p, Ft(p);
+    const M = await yn(p);
+    if (m !== A || y)
+      throw p.getTracks().forEach((re) => re.stop()), new O("Media source superseded by a newer bind");
+    l = M, f = new OffscreenCanvas(M.videoWidth, M.videoHeight);
+    const { renderWidth: b, renderHeight: P } = n.getSnapshot(), D = xn({
+      renderWidth: b,
+      renderHeight: P,
+      videoWidth: M.videoWidth,
+      videoHeight: M.videoHeight
+    });
+    u ? (u.width !== D.width || u.height !== D.height) && (u.width = D.width, u.height = D.height, me(u)) : (u = new OffscreenCanvas(D.width, D.height), me(u));
+    const je = i.source === F.STREAM ? i.static === !0 : !1;
+    L = je;
+    const ne = ($e = (fe = (Ze = p.getVideoTracks) == null ? void 0 : Ze.call(p)[0]) == null ? void 0 : fe.getSettings) == null ? void 0 : $e.call(fe), Te = ne == null ? void 0 : ne.facingMode, ss = Te === "user" || Te === "environment" ? Te : null;
+    if (i.source === F.WEBCAM) {
+      const re = ss ?? i.facingMode ?? "user", Je = lt(re, i.mirrored);
+      c = {
+        source: F.WEBCAM,
+        sourceKind: Je ? "webcam" : "rear-camera",
+        facingMode: re,
+        deviceId: i.deviceId,
+        mirrored: Je
+      };
+    } else
+      c = {
+        source: F.STREAM,
+        stream: i.stream,
+        static: je,
+        sourceKind: i.sourceKind ?? "webcam"
+      };
+    n.set({
+      source: i.source,
+      sourceKind: c.sourceKind,
+      cameraFacing: c.source === F.WEBCAM ? c.facingMode : null,
+      cameraDeviceId: c.source === F.WEBCAM ? (ne == null ? void 0 : ne.deviceId) ?? c.deviceId ?? null : null,
+      sourceWidth: M.videoWidth,
+      sourceHeight: M.videoHeight,
+      error: void 0
+    }), i.source === F.WEBCAM && It();
+  }, ke = async (i) => {
+    const m = i.sourceKind ?? "webcam";
+    u = i.canvas;
+    const p = me(u);
+    n.set({
+      cameraTexture: p,
+      source: F.CANVAS,
+      sourceKind: m,
+      cameraFacing: null,
+      cameraDeviceId: null,
+      renderWidth: u.width,
+      renderHeight: u.height,
+      error: void 0
+    }), c = {
+      source: F.CANVAS,
+      canvas: i.canvas,
+      sourceKind: m
+    };
+  }, Pt = (i, m) => {
+    if (!m || i.source !== m.source) return !1;
+    if (i.source === F.STREAM && m.source === F.STREAM)
+      return i.stream === m.stream && (i.sourceKind ?? "webcam") === m.sourceKind;
+    if (i.source === F.WEBCAM && m.source === F.WEBCAM) {
+      const p = i.facingMode ?? "user";
+      return p === m.facingMode && i.deviceId === m.deviceId && lt(p, i.mirrored) === m.mirrored;
+    }
+    return !1;
+  }, ze = async () => {
+    if (!u) return;
+    const i = A, m = n.getSnapshot().pipeline;
+    for (const [, p] of m.entries())
+      p.resume();
+    await new Promise((p) => requestAnimationFrame(() => p())), await new Promise((p) => requestAnimationFrame(() => p())), L && A === i && z.suspendAll();
+  }, Lt = (i, m) => !m || m.source !== F.CANVAS ? !1 : i.canvas === m.canvas && (i.sourceKind ?? "webcam") === m.sourceKind, Ce = async (i) => {
+    const m = i.source;
+    if (m !== F.WEBCAM && m !== F.STREAM)
+      throw new O(`Invalid media source: ${String(m)}`);
+    if (y) throw new O("session.setMediaSource() called after the provider unmounted");
+    if (Pt(i, c)) {
+      e.log("Media source unchanged, skipping rebind.");
+      return;
+    }
+    A += 1;
+    const { lifecycle: p } = n.getSnapshot();
+    if (p === "idle" || p === "stopped") {
+      await Me(i), n.set({ lifecycle: "media-bound" }), e.log("Media source set to:", i.source);
+      return;
+    }
+    if (p === "media-bound") {
+      ee(), await Me(i), e.log("Media source rebound to:", i.source);
+      return;
+    }
+    const M = p === "paused";
+    v = !0, await new Promise((b) => requestAnimationFrame(() => b())), ee();
+    try {
+      await Me(i);
+    } finally {
+      v = !1;
+    }
+    if (M) {
+      l == null || l.pause(), e.log("Media source swapped (paused) to:", i.source);
+      return;
+    }
+    Se(), L ? await ze() : z.resumeActive(), e.log("Media source swapped to:", i.source);
+  }, Dt = async (i) => {
+    if (y) throw new O("session.setFrameSource() called after the provider unmounted");
+    if (Lt(i, c)) {
+      e.log("Frame source unchanged, skipping rebind.");
+      return;
+    }
+    A += 1;
+    const { lifecycle: m } = n.getSnapshot();
+    if (m === "idle" || m === "stopped") {
+      await ke(i), n.set({ lifecycle: "media-bound" }), e.log("Frame source set to canvas.");
+      return;
+    }
+    if (m === "media-bound") {
+      ee(), await ke(i), e.log("Frame source rebound to canvas.");
+      return;
+    }
+    v = !0, await new Promise((p) => requestAnimationFrame(() => p())), ee();
+    try {
+      await ke(i);
+    } finally {
+      v = !1;
+    }
+    e.log("Frame source swapped to canvas.");
+  }, We = async () => {
+    if (y) throw new O("session.start() called after the provider unmounted");
+    const { lifecycle: i } = n.getSnapshot();
+    if (i === "running") return;
+    if (i === "paused") {
+      await xe();
+      return;
+    }
+    if (i === "idle")
+      throw new O("session.start() called before setMediaSource — call setMediaSource first");
+    if (!u)
+      throw new O("session.start(): media source not bound");
+    const m = (c == null ? void 0 : c.source) === F.CANVAS;
+    if (!m && (!l || !f))
+      throw i === "stopped" ? new O(
+        "session.start() called from stopped state without a media source — call setMediaSource first"
+      ) : new O("session.start(): media source not bound");
+    m || Se(), z.resumeActive(), n.set({ lifecycle: "running" }), await new Promise((M) => requestAnimationFrame(() => M()));
+    const p = n.getSnapshot().pipeline;
+    for (const [M, b] of p.entries())
+      await we(M, b);
+    n.set({ ready: !0 }), e.log("XR session started.");
+  }, Ve = () => {
+    if (n.getSnapshot().lifecycle === "running") {
+      Ne(), z.suspendAll();
+      try {
+        l == null || l.pause();
+      } catch {
+      }
+      n.set({ lifecycle: "paused" }), e.log("XR session paused.");
+    }
+  }, xe = async () => {
+    if (y) throw new O("session.resume() called after the provider unmounted");
+    n.getSnapshot().lifecycle === "paused" && (C = !1, l && l.play().catch(() => {
+    }), (c == null ? void 0 : c.source) !== F.CANVAS && Se(), n.set({ lifecycle: "running" }), L ? await ze() : z.resumeActive(), e.log("XR session resumed."));
+  }, Ot = async (i = {}) => {
+    await Ce({ source: F.WEBCAM, ...i });
+    const { lifecycle: m } = n.getSnapshot();
+    return (m === "media-bound" || m === "stopped") && await We(), n.getSnapshot().cameraFacing ?? i.facingMode ?? "user";
+  }, qe = async () => {
+    const { lifecycle: i } = n.getSnapshot();
+    i === "stopped" || i === "idle" || (C = !1, ee(), z.suspendAll(), c = void 0, n.set({ lifecycle: "stopped", ready: !1 }), e.log("XR session stopped."));
+  }, Ke = async () => {
+    await qe(), z.releaseAll(), K.clear();
+    const i = n.getSnapshot().cameraTexture;
+    i && i.dispose(), W = /* @__PURE__ */ new WeakSet(), c = void 0, A += 1, u = void 0, f = void 0, S = void 0, L = !1, _t(), n.set({
+      lifecycle: "idle",
+      cameraTexture: void 0,
+      source: void 0,
+      sourceKind: void 0,
+      cameraFacing: null,
+      cameraDeviceId: null,
+      error: void 0,
+      modelErrors: /* @__PURE__ */ new Map(),
+      cameraPermission: "unknown",
+      cameraPermissionReason: null
+    }), e.log("XR session reset.");
+  }, Ht = async () => {
+    y || (y = !0, se == null || se(), se = void 0, te == null || te(), te = void 0, await Ke(), e.log("XR session disposed."));
+  }, Ut = () => {
+    y && (y = !1, Qe(), Ye(), e.log("XR session re-armed."));
+  }, Nt = () => y, Bt = async (i) => {
+    const m = "legacy:registerXRPipeline", p = [];
+    await Promise.all(
+      i.map(async (M) => {
+        const { model: b } = M;
+        if (!ct[b])
+          throw new O(`Invalid model: ${b}`);
+        K.has(b) || p.push(b);
+        const P = "options" in M ? M.options : void 0;
+        await z.acquire(b, m, P);
+      })
+    ), p.length > 0 && (p.forEach((M) => K.add(M)), e.log("XR pipeline registered."));
+  }, zt = (i) => {
+    const m = z.get(i);
+    if (!m)
+      throw new O(`Model ${i} is not registered in the pipeline`);
+    return m.getModelNode();
+  }, Ge = async (i, m) => {
+    i <= 0 || m <= 0 || (n.set({ renderWidth: i, renderHeight: m }), u && (u.width !== i || u.height !== m) && (u.width = i, u.height = m, me(u), L && ve()), e.log(`Source canvas set. Render size: ${i}x${m}`));
+  }, Wt = async (i) => {
+    var b;
+    w = i;
+    const m = (b = i.getBoundingClientRect) == null ? void 0 : b.call(i), p = m && m.width > 0 ? Math.round(m.width) : i.clientWidth, M = m && m.height > 0 ? Math.round(m.height) : i.clientHeight;
+    await Ge(p, M);
+  }, Vt = (i) => {
+    S = i;
+  }, be = () => w && k && x && T ? w : S, qt = (i) => {
+    k = i.renderer, x = i.scene, T = i.camera, _ = i.renderFrame;
+  }, Xe = () => {
+    if (!k || !x || !T)
+      throw new O(
+        "XR frame render requested before the R3F state was bound — make sure <XRScene> is mounted"
+      );
+    _ ? _() : k.render(x, T);
+  }, Kt = () => {
+    const i = w;
+    if (i && be() === i)
+      return Xe(), i.toDataURL("image/png");
+    const m = be();
+    if (m) return m.toDataURL("image/png");
+    throw new O(
+      "session.captureFrame() called before an XRScene or XRMediaSurface capture target was bound"
+    );
+  }, Gt = (i = 30) => {
+    const m = be();
+    if (!(m != null && m.captureStream))
+      throw new O(
+        "session.captureStream() called before an XRScene or XRMediaSurface capture target was bound"
+      );
+    return m.captureStream(i);
+  }, Xt = () => l, Yt = () => u ?? null, Qt = (i) => {
+    if (a = i, n.set({ cameraZoom: (i == null ? void 0 : i.cameraZoom) ?? 1.2 }), n.getSnapshot().lifecycle !== "running" || !u) return;
+    const m = n.getSnapshot().pipeline;
+    for (const [p, M] of m.entries())
+      M.run({
+        sourceCanvas: u,
+        renderWidth: n.getSnapshot().renderWidth,
+        renderHeight: n.getSnapshot().renderHeight,
+        getSource: () => n.getSnapshot().sourceKind,
+        targetFps: o(p),
+        analysisScale: a == null ? void 0 : a.analysisScale
+      });
+  }, jt = () => a, Zt = async () => {
+    if (!c || c.source !== F.WEBCAM) return;
+    const { facingMode: i, deviceId: m, mirrored: p } = c;
+    c = void 0, await Ce({ source: F.WEBCAM, facingMode: i, deviceId: m, mirrored: p });
+  }, $t = (i) => {
+    n.set({ quality: i });
+  }, Jt = (i) => {
+    n.set({ qualityConfig: i });
+  }, es = (i) => {
+    r = i;
+  }, ts = () => {
+    var b;
+    if (typeof window > "u") return { type: "portrait", angle: 0 };
+    const i = (b = window.screen) == null ? void 0 : b.orientation, m = (i == null ? void 0 : i.angle) ?? 0, p = m === 90 || m === 180 || m === 270 ? m : 0;
+    return { type: i != null && i.type ? i.type.startsWith("landscape") ? "landscape" : "portrait" : window.innerWidth > window.innerHeight ? "landscape" : "portrait", angle: p };
+  }, oe = () => {
+    const i = ts(), m = n.getSnapshot().orientation, p = m.type !== i.type || m.angle !== i.angle ? { orientation: i } : {};
+    l && l.videoWidth > 0 && (p.sourceWidth = l.videoWidth, p.sourceHeight = l.videoHeight), Object.keys(p).length && n.set(p);
+  };
+  let te;
+  const Ye = () => {
+    var m, p, M;
+    if (te || typeof window > "u") return;
+    const i = (m = window.screen) == null ? void 0 : m.orientation;
+    (p = i == null ? void 0 : i.addEventListener) == null || p.call(i, "change", oe), (M = window.addEventListener) == null || M.call(window, "resize", oe), te = () => {
+      var b, P;
+      (b = i == null ? void 0 : i.removeEventListener) == null || b.call(i, "change", oe), (P = window.removeEventListener) == null || P.call(window, "resize", oe);
+    }, oe();
+  };
+  let se;
+  const Qe = () => {
+    if (se || typeof document > "u" || typeof document.addEventListener != "function") return;
+    const i = () => {
+      if (!y) {
+        if (document.hidden) {
+          r != null && r.pauseWhenHidden && n.getSnapshot().lifecycle === "running" && (Ve(), C = !0);
+          return;
+        }
+        if (C && n.getSnapshot().lifecycle === "paused") {
+          xe();
+          return;
+        }
+        n.getSnapshot().lifecycle === "running" && (l != null && l.paused) && l.play().catch(() => {
+        });
+      }
+    };
+    document.addEventListener("visibilitychange", i), se = () => document.removeEventListener("visibilitychange", i);
+  };
+  return Qe(), Ye(), {
+    store: n,
+    registry: z,
+    setMediaSource: Ce,
+    start: We,
+    stop: qe,
+    reset: Ke,
+    pause: Ve,
+    resume: xe,
+    switchCamera: Ot,
+    dispose: Ht,
+    rearm: Ut,
+    isDisposed: Nt,
+    setFrameSource: Dt,
+    registerXRPipeline: Bt,
+    getModelNode: zt,
+    captureFrame: Kt,
+    captureStream: Gt,
+    getInputFrame: Yt,
+    _setRenderTarget: Wt,
+    _setCaptureTarget: Vt,
+    _setRenderSize: Ge,
+    _setR3FState: qt,
+    _renderFrame: Xe,
+    _getVideoElement: Xt,
+    _setPerf: Qt,
+    _setLifecycle: es,
+    _rebindMedia: Zt,
+    _setQuality: $t,
+    _setQualityConfig: Jt,
+    _getPerf: jt
+  };
+}, Tn = (t, s) => {
+  const e = ie(t), n = ie(s), r = he(
+    () => bn(e.current, n.current),
+    []
+  ), a = JSON.stringify(s ?? {});
+  ce(() => {
+    r._setLifecycle(s);
+  }, [r, a]), ce(() => (r.rearm(), () => void r.dispose()), [r]);
+  const o = JSON.stringify(t ?? {});
+  return ce(() => {
+    r._setPerf(t);
+  }, [r, o]), r;
+}, _e = /* @__PURE__ */ new Map(), En = () => ({
+  register: (t, s) => {
+    s ? _e.set(t, s) : _e.delete(t);
+  },
+  resolve: (t) => t ? _e.get(t) ?? null : null
+}), Ct = En(), xt = ut(null), An = ({ children: t }) => {
+  const s = ie(/* @__PURE__ */ new Map()), e = tt((a, o) => {
+    o ? s.current.set(a, o) : s.current.delete(a);
+  }, []), n = tt(
+    (a) => a ? s.current.get(a) ?? null : null,
+    []
+  ), r = he(() => ({ register: e, resolve: n }), [e, n]);
+  return is(xt.Provider, { value: r }, t);
+}, bt = () => De(xt) ?? Ct, fr = () => bt().register, gr = () => bt().resolve;
+Ct.register;
+const Rn = {
+  [R.FACE_TRACKER]: "face",
+  [R.HAND_TRACKER]: "hand",
+  [R.GESTURE_TRACKER]: "gesture",
+  [R.BODY_TRACKER]: "body",
+  [R.HOLISTIC_TRACKER]: "holistic",
+  [R.BACKGROUND_SEGMENTATION]: "segmentation",
+  [R.SEMANTIC_SEGMENTATION]: "semantic-seg"
+}, dt = Object.values(R), Fn = (t, s) => {
+  var n;
+  const e = (n = t.registry.getOptions(s)) == null ? void 0 : n.targetFps;
+  return typeof e == "number" ? e : null;
+}, Le = (t, s, e, n = performance.now()) => {
+  const r = t.store.getSnapshot(), a = e ? n - e.sampledAt : 0, o = e && a > 0 ? Math.max(0, (r.feedFrames - e.feedFrames) * 1e3 / a) : 0, c = r.lifecycle === "running", l = s.map((f) => {
+    var T;
+    const u = t.registry.getState(f), w = t.store.getSnapshot().pipeline.get(f), S = ((T = r.modelErrors.get(f)) == null ? void 0 : T.error) ?? null, k = (w == null ? void 0 : w.getDiagnostics()) ?? {
+      inferenceMs: null,
+      inferenceFps: 0,
+      inferences: 0,
+      skippedFrames: 0,
+      detections: null,
+      confidence: null,
+      status: S ? "error" : "ready",
+      error: S,
+      paused: !1,
+      disposed: !1
+    };
+    let x;
+    return u === "error" || k.status === "error" ? x = "error" : u === "idle" ? x = "unavailable" : u === "initializing" ? x = "loading" : k.paused || !c ? x = "paused" : x = "ready", {
+      ...k,
+      error: k.error ?? S,
+      model: f,
+      label: Rn[f] ?? f,
+      state: x,
+      targetFps: Fn(t, f),
+      owners: t.registry.getOwners(f)
+    };
+  }), h = r.quality;
+  return {
+    quality: h ? {
+      tier: h.decision.tier.name,
+      index: h.index,
+      locked: h.locked,
+      reason: h.decision.reason
+    } : null,
+    session: {
+      lifecycle: r.lifecycle,
+      ready: r.ready,
+      error: r.error,
+      source: r.source,
+      sourceKind: r.sourceKind,
+      sourceWidth: r.sourceWidth,
+      sourceHeight: r.sourceHeight,
+      renderWidth: r.renderWidth,
+      renderHeight: r.renderHeight,
+      feedFps: o,
+      feedFrames: r.feedFrames
+    },
+    models: l,
+    inferenceMsTotal: l.reduce(
+      (f, u) => f + (u.state === "ready" ? u.inferenceMs ?? 0 : 0),
+      0
+    ),
+    sampledAt: n
+  };
+}, pr = (t = {}) => {
+  const { intervalMs: s = 250, enabled: e = !0 } = t, { session: n } = At(), r = (t.models ?? dt).join("|"), a = he(
+    () => t.models && t.models.length ? t.models : dt,
+    // modelsKey captures the list by value.
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [r]
+  ), o = ie(null), [c, l] = os(
+    () => Le(n, a, null)
+  );
+  return ce(() => {
+    if (!e) return;
+    const h = () => {
+      const u = Le(n, a, o.current);
+      o.current = { feedFrames: u.session.feedFrames, sampledAt: u.sampledAt }, l(u);
+    };
+    h();
+    const f = window.setInterval(h, Math.max(50, s));
+    return () => window.clearInterval(f);
+  }, [n, a, s, e]), c;
+}, In = [
+  { name: "high", targetFps: 30, renderScale: 1, analysisScale: 1, camRes: 960 },
+  { name: "medium", targetFps: 24, renderScale: 0.8, analysisScale: 0.85, camRes: 720 },
+  { name: "low", targetFps: 15, renderScale: 0.6, analysisScale: 0.7, camRes: 640 }
+], Q = {
+  maxFrameMs: 1e3 / 24,
+  maxInferenceMs: 24,
+  maxMemoryMb: null,
+  sampleMs: 1e3,
+  downgradeAfter: 2,
+  upgradeAfter: 6,
+  upgradeHeadroom: 0.75,
+  cooldownMs: 4e3
+}, Tt = {
+  frameMs: null,
+  fps: null,
+  inferenceMs: null,
+  feedFps: null,
+  memoryMb: null,
+  deviceMemoryGb: null,
+  hardwareConcurrency: null,
+  thermal: "unknown"
+}, ue = (t, s, e) => Math.min(e, Math.max(s, t)), H = (t, s) => typeof t == "number" && Number.isFinite(t) ? t : s, _n = (t, s) => ({
+  name: typeof t.name == "string" && t.name ? t.name : `tier-${s}`,
+  ...H(t.targetFps, NaN) > 0 ? { targetFps: H(t.targetFps, 0) } : {},
+  ...H(t.renderScale, NaN) > 0 ? { renderScale: ue(H(t.renderScale, 1), 0.25, 1) } : {},
+  ...H(t.analysisScale, NaN) > 0 ? { analysisScale: ue(H(t.analysisScale, 1), 0.25, 1) } : {},
+  ...H(t.camRes, NaN) > 0 ? { camRes: Math.round(H(t.camRes, 0)) } : {},
+  ...t.rebindCamera ? { rebindCamera: !0 } : {}
+}), Pn = (t = {}) => ({
+  maxFrameMs: Math.max(1, H(t.maxFrameMs, Q.maxFrameMs)),
+  maxInferenceMs: Math.max(
+    0,
+    H(t.maxInferenceMs, Q.maxInferenceMs)
+  ),
+  maxMemoryMb: t.maxMemoryMb === null || t.maxMemoryMb === void 0 ? null : Math.max(1, H(t.maxMemoryMb, 0)) || null,
+  sampleMs: Math.max(100, H(t.sampleMs, Q.sampleMs)),
+  downgradeAfter: Math.max(
+    1,
+    Math.round(H(t.downgradeAfter, Q.downgradeAfter))
+  ),
+  upgradeAfter: Math.max(
+    1,
+    Math.round(H(t.upgradeAfter, Q.upgradeAfter))
+  ),
+  upgradeHeadroom: ue(
+    H(t.upgradeHeadroom, Q.upgradeHeadroom),
+    0.1,
+    1
+  ),
+  cooldownMs: Math.max(0, H(t.cooldownMs, Q.cooldownMs))
+}), Y = (t, s, e) => {
+  if (typeof s == "number" && Number.isInteger(s) && s >= 0 && s < t.length)
+    return s;
+  if (typeof s == "string") {
+    const n = t.findIndex((r) => r.name === s);
+    if (n >= 0) return n;
+  }
+  return e;
+}, Ln = (t = {}) => {
+  const s = t.tiers && t.tiers.length ? t.tiers.map((r, a) => _n(r, a)) : In, e = Y(s, t.maxTier, 0), n = Math.max(e, Y(s, t.minTier, s.length - 1));
+  return {
+    tiers: s,
+    budget: Pn(t.budget),
+    ...t.initialTier !== void 0 ? { initialTier: t.initialTier } : {},
+    minTier: n,
+    maxTier: e,
+    adaptive: t.adaptive !== !1,
+    historySize: Math.max(1, Math.round(H(t.historySize, 20)))
+  };
+}, Dn = (t, s) => {
+  const e = Y(t.tiers, t.maxTier, 0), n = Y(t.tiers, t.minTier, t.tiers.length - 1);
+  if (t.initialTier !== void 0)
+    return ue(Y(t.tiers, t.initialTier, e), e, n);
+  const r = s.deviceMemoryGb !== null && s.deviceMemoryGb <= 4 || s.hardwareConcurrency !== null && s.hardwareConcurrency <= 4;
+  return ue(r ? e + 1 : e, e, n);
+}, Et = (t, s = Tt, e = 0) => {
+  const n = Dn(t, s), r = { index: n, tier: t.tiers[n], reason: "init", at: e };
+  return {
+    index: n,
+    locked: !1,
+    badStreak: 0,
+    goodStreak: 0,
+    lastChangeAt: e,
+    decision: r,
+    history: [r],
+    signals: s
+  };
+}, ye = (t, s, e, n, r, a = t.signals) => {
+  const o = { index: e, tier: s.tiers[e], reason: n, at: r };
+  return {
+    ...t,
+    index: e,
+    badStreak: 0,
+    goodStreak: 0,
+    lastChangeAt: r,
+    decision: o,
+    history: [o, ...t.history].slice(0, s.historySize),
+    signals: a
+  };
+}, On = (t, s) => t.thermal === "critical" ? "thermal" : s.maxMemoryMb !== null && t.memoryMb !== null && t.memoryMb > s.maxMemoryMb ? "memory" : t.inferenceMs !== null && t.inferenceMs > s.maxInferenceMs ? "inference" : t.frameMs !== null && t.frameMs > s.maxFrameMs ? "frame-time" : null, Hn = (t, s, e, n) => {
+  const { budget: r } = e, a = Y(e.tiers, e.maxTier, 0), o = Y(e.tiers, e.minTier, e.tiers.length - 1);
+  if (t.locked || !e.adaptive) return { ...t, signals: s };
+  const c = On(s, r), l = c === null && s.frameMs !== null && s.frameMs <= r.maxFrameMs * r.upgradeHeadroom && (s.inferenceMs === null || s.inferenceMs <= r.maxInferenceMs * r.upgradeHeadroom), h = c ? t.badStreak + 1 : 0, f = l ? t.goodStreak + 1 : 0, u = n - t.lastChangeAt >= r.cooldownMs;
+  if (c && h >= r.downgradeAfter && u) {
+    if (t.index < o)
+      return ye(t, e, t.index + 1, c, n, s);
+    const w = c === "frame-time" ? "suspected" : s.thermal;
+    return { ...t, badStreak: h, goodStreak: f, signals: { ...s, thermal: w } };
+  }
+  return l && f >= r.upgradeAfter && u && t.index > a ? ye(t, e, t.index - 1, "recovered", n, s) : { ...t, badStreak: h, goodStreak: f, signals: s };
+}, yr = (t, s, e, n) => {
+  const r = Y(s.tiers, e, t.index);
+  return r === t.index ? t : ye(t, s, r, "manual", n);
+}, wr = (t, s, e, n) => e === t.locked ? t : { ...ye(t, s, t.index, e ? "locked" : "manual", n), locked: e }, Un = (t, s) => t.decision.tier === s ? null : t.decision.tier, vr = (t, s, e) => {
+  const n = Et(t, s, e);
+  return {
+    ...n,
+    decision: { ...n.decision, reason: "reset" },
+    history: [{ ...n.decision, reason: "reset" }]
+  };
+}, Nn = Object.values(R), Bn = () => {
+  if (typeof navigator > "u") return { deviceMemoryGb: null, hardwareConcurrency: null };
+  const t = navigator;
+  return {
+    deviceMemoryGb: typeof t.deviceMemory == "number" ? t.deviceMemory : null,
+    hardwareConcurrency: typeof t.hardwareConcurrency == "number" ? t.hardwareConcurrency : null
+  };
+}, zn = () => {
+  const t = performance.memory;
+  return t ? t.usedJSHeapSize / 1048576 : null;
+}, Wn = ({ config: t, thermal: s, onDecision: e }) => {
+  const { session: n } = At(), r = JSON.stringify(t ?? {}), a = he(() => Ln(t), [r]), o = ie(s ?? "unknown");
+  o.current = s ?? "unknown";
+  const c = ie(e);
+  return c.current = e, ce(() => {
+    const l = Bn();
+    let h = Et(
+      a,
+      { ...Tt, ...l },
+      performance.now()
+    );
+    const f = n.store.getSnapshot().quality;
+    f && f.index < a.tiers.length && (h = {
+      ...f,
+      decision: { ...f.decision, tier: a.tiers[f.index] }
+    }), n._setQualityConfig(a), n._setQuality(h);
+    let u = n._getPerf(), w = null;
+    const S = async (y, C) => {
+      const N = {
+        ...u,
+        ...y.targetFps !== void 0 ? { targetFps: y.targetFps } : {},
+        ...y.analysisScale !== void 0 ? { analysisScale: y.analysisScale } : {},
+        ...y.camRes !== void 0 && y.rebindCamera ? { camRes: y.camRes } : {}
+      };
+      n._setPerf(N), y.rebindCamera && y.camRes !== void 0 && y.camRes !== (C == null ? void 0 : C.camRes) && await n._rebindMedia().catch(() => {
+      });
+    };
+    w = h.decision.tier, S(h.decision.tier, null);
+    let k = 0, x = performance.now(), T = 0;
+    const _ = () => {
+      k += 1, T = requestAnimationFrame(_);
+    };
+    T = requestAnimationFrame(_);
+    let g = null;
+    const v = window.setInterval(() => {
+      var W;
+      if (typeof document < "u" && document.hidden) {
+        k = 0, x = performance.now();
+        return;
+      }
+      const y = performance.now(), C = y - x, N = Le(n, Nn, g, y);
+      g = { feedFrames: N.session.feedFrames, sampledAt: y };
+      const E = n.store.getSnapshot().lifecycle === "running", V = {
+        frameMs: k > 0 && C > 0 && E ? C / k : null,
+        fps: k > 0 && C > 0 ? k * 1e3 / C : null,
+        inferenceMs: E ? N.inferenceMsTotal : null,
+        feedFps: N.session.feedFps,
+        memoryMb: zn(),
+        ...l,
+        thermal: o.current
+      };
+      k = 0, x = y;
+      const q = n.store.getSnapshot().quality ?? h, L = Hn(q, V, a, y);
+      h = L, n._setQuality(L);
+      const A = Un(L, w);
+      if (A) {
+        const K = w;
+        w = A, S(A, K), (W = c.current) == null || W.call(c, L);
+      }
+    }, a.budget.sampleMs);
+    return () => {
+      cancelAnimationFrame(T), window.clearInterval(v);
+      const y = (w == null ? void 0 : w.rebindCamera) && w.camRes !== void 0;
+      n._setPerf(u), y && (u == null ? void 0 : u.camRes) !== (w == null ? void 0 : w.camRes) && n._rebindMedia().catch(() => {
+      }), u = void 0, n._setQualityConfig(null);
+    };
+  }, [n, a]), null;
+}, Ue = ut(void 0), At = () => {
+  const t = De(Ue);
+  if (!t)
+    throw new O(
+      "XR context can only be used inside XRProvider, did you forget to wrap your app in <XRProvider>?"
+    );
+  return t;
+}, Sr = () => De(Ue) ?? null, Mr = ({ children: t, perf: s, lifecycle: e, quality: n }) => {
+  const r = Tn(s, e), a = he(() => ({ session: r }), [r]);
+  return /* @__PURE__ */ as(Ue.Provider, { value: a, children: [
+    n !== !1 && /* @__PURE__ */ et(Wn, { config: n || void 0 }),
+    /* @__PURE__ */ et(An, { children: t })
+  ] });
+};
+export {
+  er as $,
+  Zn as A,
+  vt as B,
+  Mt as C,
+  gt as D,
+  pr as E,
+  ps as F,
+  Rn as G,
+  Rs as H,
+  Tt as I,
+  Et as J,
+  On as K,
+  wr as L,
+  Bn as M,
+  vr as N,
+  Dn as O,
+  Pn as P,
+  _n as Q,
+  yr as R,
+  ot as S,
+  Hn as T,
+  Un as U,
+  hn as V,
+  hr as W,
+  R as X,
+  Oe as Y,
+  St as Z,
+  Jn as _,
+  Ls as a,
+  tr as a0,
+  sr as a1,
+  Ln as a2,
+  Ws as a3,
+  Mr as a4,
+  Os as a5,
+  rr as a6,
+  ar as a7,
+  ir as a8,
+  or as a9,
+  nr as aa,
+  lr as ab,
+  dr as ac,
+  pt as ad,
+  xs as ae,
+  yt as af,
+  Q as ag,
+  In as ah,
+  Wn as ai,
+  fr as aj,
+  ur as b,
+  Ds as c,
+  jn as d,
+  un as e,
+  mr as f,
+  F as g,
+  Sr as h,
+  He as i,
+  I as j,
+  Fe as k,
+  U as l,
+  $n as m,
+  le as n,
+  Us as o,
+  zs as p,
+  gr as q,
+  cr as r,
+  wt as s,
+  Qn as t,
+  At as u,
+  Pe as v,
+  ys as w,
+  ws as x,
+  vs as y,
+  Le as z
+};