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

package/dist/index-CIe7eCMH.js

@@ -0,0 +1,3200 @@
+var cs = Object.defineProperty;
+var ls = (e, s, t) => s in e ? cs(e, s, { enumerable: !0, configurable: !0, writable: !0, value: t }) : e[s] = t;
+var u = (e, s, t) => ls(e, typeof s != "symbol" ? s + "" : s, t);
+import { jsxs as ds, jsx as rt } from "react/jsx-runtime";
+import { useRef as oe, useMemo as ge, useEffect as he, useContext as Be, useCallback as at, createElement as hs, createContext as gt, useState as us } from "react";
+import { FilesetResolver as Q, PoseLandmarker as ms, FaceLandmarker as fs, GestureRecognizer as gs, HolisticLandmarker as ps, HandLandmarker as ys, ImageSegmenter as pt, DrawingUtils as ws } from "@mediapipe/tasks-vision";
+import * as B from "three";
+import { RGBAFormat as yt, LinearFilter as ve, CanvasTexture as wt, SRGBColorSpace as vs } from "three";
+const z = {
+  // 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__ */ ((e) => (e.WEBCAM = "webcam", e.STREAM = "stream", e.CANVAS = "canvas", e))(F || {}), R = /* @__PURE__ */ ((e) => (e.HAND_TRACKER = "vincentt.xr.hand-tracker", e.GESTURE_TRACKER = "vincentt.xr.gesture-tracker", e.FACE_TRACKER = "vincentt.xr.face-tracker", e.BODY_TRACKER = "vincentt.xr.body-tracker", e.HOLISTIC_TRACKER = "vincentt.xr.holistic-tracker", e.BACKGROUND_SEGMENTATION = "vincentt.xr.background-segmentation", e.SEMANTIC_SEGMENTATION = "vincentt.xr.semantic-segmentation", e))(R || {});
+const Ie = (e) => Array.from({ length: e }, () => ({ x: 0, y: 0, z: 0 }));
+class Ss {
+  constructor(s) {
+    u(this, "slots", []);
+    this.options = s;
+  }
+  setOptions(s) {
+    this.options = s;
+  }
+  /** Landmark sets to draw this frame: live faces, plus held/predicted ones. */
+  update(s, t) {
+    const { holdMs: n, predictMs: r, maxVelocityGapMs: a = 250 } = this.options, c = [], o = Math.max(s.length, this.slots.length);
+    for (let d = 0; d < o; d += 1) {
+      const l = s[d], h = this.slots[d] ?? null;
+      if (l && l.length > 0) {
+        const S = h && h.points.length === l.length ? h : null, M = S ?? {
+          points: Ie(l.length),
+          velocity: Ie(l.length),
+          lastSeen: t,
+          output: Ie(l.length)
+        }, C = (t - M.lastSeen) / 1e3, E = S !== null && C > 0 && C * 1e3 <= a;
+        for (let _ = 0; _ < l.length; _ += 1) {
+          const g = l[_], v = M.points[_], w = M.velocity[_], x = g.z ?? 0;
+          E ? (w.x = 0.5 * w.x + 0.5 * ((g.x - v.x) / C), w.y = 0.5 * w.y + 0.5 * ((g.y - v.y) / C), w.z = 0.5 * w.z + 0.5 * ((x - v.z) / C)) : (w.x = 0, w.y = 0, w.z = 0), v.x = g.x, v.y = g.y, v.z = x;
+        }
+        M.lastSeen = t, this.slots[d] = M, c.push(l);
+        continue;
+      }
+      if (!h) continue;
+      const m = t - h.lastSeen;
+      if (m > n) {
+        this.slots[d] = null;
+        continue;
+      }
+      const y = Math.max(0, Math.min(m, r)) / 1e3;
+      for (let S = 0; S < h.points.length; S += 1)
+        h.output[S].x = h.points[S].x + h.velocity[S].x * y, h.output[S].y = h.points[S].y + h.velocity[S].y * y, h.output[S].z = h.points[S].z + h.velocity[S].z * y;
+      c.push(h.output);
+    }
+    for (; this.slots.length > 0 && this.slots[this.slots.length - 1] === null; ) this.slots.pop();
+    return c;
+  }
+  reset() {
+    this.slots = [];
+  }
+}
+const ue = (e, s = { x: 0, y: 0, z: 0 }) => (s.x = e.x * 2 - 1, s.y = 1 - e.y * 2, s.z = -e.z, s), fr = (e, s = { x: 0, y: 0, z: 0 }) => (s.x = (e.x + 1) / 2, s.y = (1 - e.y) / 2, s.z = -e.z, s), vt = "https://storage.googleapis.com/mediapipe-models/holistic_landmarker/holistic_landmarker/float16/latest/holistic_landmarker.task", Ms = 250, Cs = 0, ks = 768, Ne = (e) => ({
+  hands: (e == null ? void 0 : e.hands) ?? "both",
+  analysisMaxDimension: (e == null ? void 0 : e.analysisMaxDimension) ?? ks,
+  holdMs: (e == null ? void 0 : e.holdMs) ?? Ms,
+  predictMs: (e == null ? void 0 : e.predictMs) ?? Cs
+}), xs = () => ({
+  version: 0,
+  timestampMs: 0,
+  face: null,
+  leftHand: null,
+  rightHand: null,
+  pose: null
+}), it = [
+  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
+], ot = (e, s) => {
+  if (e.length !== it.length) return e;
+  s.length = e.length;
+  for (let t = 0; t < e.length; t += 1) s[t] = e[it[t]];
+  return s;
+};
+class we {
+  constructor(s, t) {
+    u(this, "memory");
+    u(this, "holdMs");
+    u(this, "lastLiveMs", -1 / 0);
+    u(this, "lastConfidence", 0);
+    this.holdMs = s, this.memory = new Ss({ holdMs: s, predictMs: t });
+  }
+  setOptions(s, t) {
+    this.holdMs = s, this.memory.setOptions({ holdMs: s, predictMs: t });
+  }
+  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, t, 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 = t, { points: a, held: !1, confidence: t };
+    const c = n - this.lastLiveMs, o = this.holdMs > 0 ? Math.max(0, 1 - c / this.holdMs) : 0;
+    return { points: a, held: !0, confidence: this.lastConfidence * o };
+  }
+}
+const ae = (e, s, t) => {
+  for (e.length > s && (e.length = s); e.length < s; ) e.push(t());
+  return e;
+}, _e = (e, s) => {
+  e.x = s.x, e.y = s.y, e.z = s.z;
+}, bs = (e) => {
+  if (e.length === 0) return 0;
+  let s = 0;
+  for (let t = 0; t < e.length; t += 1) s += e[t].visibility ?? 0;
+  return s / e.length;
+};
+class Ts {
+  constructor(s) {
+    u(this, "options", Ne());
+    u(this, "faceMemory", new we(this.options.holdMs, this.options.predictMs));
+    u(this, "leftHandMemory", new we(this.options.holdMs, this.options.predictMs));
+    u(this, "rightHandMemory", new we(this.options.holdMs, this.options.predictMs));
+    u(this, "poseMemory", new we(this.options.holdMs, this.options.predictMs));
+    u(this, "face", {
+      landmarks: [],
+      blendshapes: {},
+      confidence: 0,
+      held: !1
+    });
+    u(this, "leftHand", {
+      handedness: "left",
+      landmarks: [],
+      worldLandmarks: [],
+      confidence: 0,
+      held: !1
+    });
+    u(this, "rightHand", {
+      handedness: "right",
+      landmarks: [],
+      worldLandmarks: [],
+      confidence: 0,
+      held: !1
+    });
+    u(this, "poseScratch", []);
+    u(this, "poseWorldScratch", []);
+    u(this, "pose", {
+      landmarks: [],
+      worldLandmarks: [],
+      visibility: [],
+      confidence: 0,
+      held: !1
+    });
+    this.setOptions(s);
+  }
+  getOptions() {
+    return this.options;
+  }
+  setOptions(s) {
+    this.options = Ne({ ...this.options, ...s });
+    const { holdMs: t, predictMs: n } = this.options;
+    for (const r of this.memories()) r.setOptions(t, 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, t, n, r = !1) {
+    var l, h, m, y;
+    n.face = this.updateFace(s, t);
+    const a = {
+      landmarks: (l = s == null ? void 0 : s.leftHandLandmarks) == null ? void 0 : l[0],
+      world: (h = s == null ? void 0 : s.leftHandWorldLandmarks) == null ? void 0 : h[0]
+    }, c = {
+      landmarks: (m = s == null ? void 0 : s.rightHandLandmarks) == null ? void 0 : m[0],
+      world: (y = s == null ? void 0 : s.rightHandWorldLandmarks) == null ? void 0 : y[0]
+    }, o = r ? c : a, d = r ? a : c;
+    return n.leftHand = this.updateHand("left", o.landmarks, o.world, t), n.rightHand = this.updateHand("right", d.landmarks, d.world, t), n.pose = this.updatePose(s, t, r), n.timestampMs = t, n.version += 1, n;
+  }
+  updateFace(s, t) {
+    var o, d, l, h;
+    const n = (o = s == null ? void 0 : s.faceLandmarks) == null ? void 0 : o[0], r = this.faceMemory.bridge(n, 1, t);
+    if (!r) return null;
+    const { face: a } = this, c = !r.held && n;
+    ae(a.landmarks, r.points.length, () => ({
+      x: 0,
+      y: 0,
+      z: 0,
+      visibility: 0
+    }));
+    for (let m = 0; m < r.points.length; m += 1) {
+      const y = a.landmarks[m];
+      _e(y, r.points[m]), y.visibility = c ? ((d = n[m]) == null ? void 0 : d.visibility) ?? 0 : 0;
+    }
+    if (c) {
+      const m = (h = (l = s == null ? void 0 : s.faceBlendshapes) == null ? void 0 : l[0]) == null ? void 0 : h.categories;
+      if (m)
+        for (const y of m) a.blendshapes[y.categoryName] = y.score;
+    }
+    return a.confidence = r.confidence, a.held = r.held, a;
+  }
+  updateHand(s, t, n, r) {
+    const a = s === "left" ? this.leftHandMemory : this.rightHandMemory, { hands: c } = this.options;
+    if (c === "none" || c !== "both" && c !== s)
+      return a.reset(), null;
+    const o = a.bridge(t, 1, r);
+    if (!o) return null;
+    const d = s === "left" ? this.leftHand : this.rightHand;
+    ae(d.landmarks, o.points.length, () => ({ x: 0, y: 0, z: 0 }));
+    for (let l = 0; l < o.points.length; l += 1)
+      ue(o.points[l], d.landmarks[l]);
+    if (!o.held && n) {
+      ae(d.worldLandmarks, n.length, () => ({ x: 0, y: 0, z: 0 }));
+      for (let l = 0; l < n.length; l += 1) _e(d.worldLandmarks[l], n[l]);
+    }
+    return d.confidence = o.confidence, d.held = o.held, d;
+  }
+  updatePose(s, t, n) {
+    var m, y, S;
+    const r = (m = s == null ? void 0 : s.poseLandmarks) == null ? void 0 : m[0], a = r && n ? ot(r, this.poseScratch) : r, c = this.poseMemory.bridge(a, a ? bs(a) : 0, t);
+    if (!c) return null;
+    const { pose: o } = this, d = !c.held && a;
+    ae(o.landmarks, c.points.length, () => ({ x: 0, y: 0, z: 0 })), ae(o.visibility, c.points.length, () => 0);
+    for (let M = 0; M < c.points.length; M += 1)
+      ue(c.points[M], o.landmarks[M]), d && (o.visibility[M] = ((y = a[M]) == null ? void 0 : y.visibility) ?? 0);
+    const l = (S = s == null ? void 0 : s.poseWorldLandmarks) == null ? void 0 : S[0], h = l && n ? ot(l, this.poseWorldScratch) : l;
+    if (d && h) {
+      ae(o.worldLandmarks, h.length, () => ({ x: 0, y: 0, z: 0 }));
+      for (let M = 0; M < h.length; M += 1) _e(o.worldLandmarks[M], h[M]);
+    }
+    return o.confidence = c.confidence, o.held = c.held, o;
+  }
+}
+const St = {
+  "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."
+}, Es = {
+  "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 = (e, s = St[e]) => ({ code: e, message: s, recoverable: Es[e] }), As = {
+  [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]: vt
+}, Mt = (e) => {
+  const s = As[e];
+  return s ? /^https?:/.test(s) ? s : new URL(s, z.assetStorageEndpoint).toString() : null;
+}, Rs = Object.values(R), Fs = () => {
+  var t, n, r;
+  const e = typeof window < "u", s = typeof document < "u";
+  return {
+    navigator: typeof navigator < "u" ? navigator : void 0,
+    isSecureContext: e ? 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" && ((t = navigator.xr) != null && t.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
+  };
+}, Is = (e) => !!e && /Android/.test(e) && /(Chrome|SamsungBrowser)\//.test(e) && !/Firefox|OPR\//.test(e), _s = async (e) => {
+  let s = !1;
+  if (e.xrSessionSupported)
+    try {
+      s = await e.xrSessionSupported("immersive-ar");
+    } catch {
+      s = !1;
+    }
+  const t = Is(e.userAgent), n = e.relSupportsAr === !0, r = s || t || n;
+  return {
+    webxr: s,
+    sceneViewer: t,
+    quickLook: n,
+    any: r,
+    reason: r ? null : I("placement-unsupported")
+  };
+}, Ps = (e) => {
+  switch (e) {
+    case "granted":
+      return "supported";
+    case "denied":
+      return "permission-denied";
+    case "prompt":
+      return "permission-prompt";
+    default:
+      return "unknown";
+  }
+}, Ds = async (e, s) => {
+  var o, d, l;
+  const t = e.isSecureContext ?? !0, n = (o = e.navigator) == null ? void 0 : o.mediaDevices;
+  if (!t)
+    return {
+      status: "unsupported",
+      reason: I("camera-insecure-context"),
+      deviceCount: null,
+      secureContext: t
+    };
+  if (!n || typeof n.getUserMedia != "function")
+    return {
+      status: "unsupported",
+      reason: I("camera-unsupported"),
+      deviceCount: null,
+      secureContext: t
+    };
+  let r = "unknown";
+  if (s && ((l = (d = e.navigator) == null ? void 0 : d.permissions) != null && l.query))
+    try {
+      const h = await e.navigator.permissions.query({ name: "camera" });
+      r = Ps(h.state);
+    } catch {
+      r = "unknown";
+    }
+  let a = null, c = !1;
+  if (typeof n.enumerateDevices == "function")
+    try {
+      const h = await n.enumerateDevices();
+      a = h.filter((m) => m.kind === "videoinput").length, c = h.some((m) => !!m.label);
+    } catch {
+      a = null;
+    }
+  return r === "permission-denied" ? {
+    status: r,
+    reason: I("camera-permission-denied"),
+    deviceCount: a,
+    secureContext: t
+  } : a === 0 && (r === "supported" || c) ? {
+    status: "unsupported",
+    reason: I("no-camera"),
+    deviceCount: a,
+    secureContext: t
+  } : { status: r, reason: null, deviceCount: a, secureContext: t };
+}, Ls = (e) => {
+  var t;
+  const s = (t = e.createCanvas) == null ? void 0 : t.call(e);
+  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;
+}, Os = (e) => {
+  var c;
+  const s = Ls(e), t = e.offscreenCanvas ?? !1, n = e.wasm ?? !1, r = !!((c = e.navigator) != null && c.gpu);
+  let a = null;
+  return s === 0 ? a = I("webgl-unavailable") : t ? n || (a = I("wasm-unavailable")) : a = I("offscreen-canvas-unavailable"), {
+    status: a ? "unsupported" : "supported",
+    reason: a,
+    webglVersion: s,
+    webgpu: r,
+    offscreenCanvas: t,
+    wasm: n
+  };
+}, Hs = async (e, s, t) => {
+  var c, o;
+  const n = Mt(e);
+  if (!n || !s.fetch)
+    return { model: e, 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(), t);
+  try {
+    const d = await s.fetch(n, { method: "HEAD", signal: r == null ? void 0 : r.signal });
+    if (!d.ok)
+      return {
+        model: e,
+        status: "unsupported",
+        reason: I(
+          "model-unreachable",
+          `${St["model-unreachable"]} (${d.status})`
+        ),
+        url: n,
+        bytes: null
+      };
+    const l = Number(((o = (c = d.headers) == null ? void 0 : c.get) == null ? void 0 : o.call(c, "content-length")) ?? NaN);
+    return {
+      model: e,
+      status: "supported",
+      reason: null,
+      url: n,
+      bytes: Number.isFinite(l) && l > 0 ? l : null
+    };
+  } catch {
+    return {
+      model: e,
+      status: "unsupported",
+      reason: I("model-unreachable"),
+      url: n,
+      bytes: null
+    };
+  } finally {
+    clearTimeout(a);
+  }
+}, gr = async (e = {}, s = Fs()) => {
+  const t = e.timeoutMs ?? 4e3, n = new Set(e.models ?? []), [r, a, c] = await Promise.all([
+    Ds(s, e.queryPermission ?? !0),
+    Promise.all(
+      Rs.map(
+        async (l) => n.has(l) ? Hs(l, s, t) : {
+          model: l,
+          status: "unknown",
+          reason: null,
+          url: Mt(l),
+          bytes: null
+        }
+      )
+    ),
+    _s(s)
+  ]), o = Os(s), d = Object.fromEntries(a.map((l) => [l.model, l]));
+  return {
+    camera: r,
+    rendering: o,
+    placement: c,
+    models: d,
+    canRunTracking: o.status === "supported" && r.status !== "unsupported",
+    checkedAt: s.now ? s.now() : Date.now()
+  };
+}, Ct = (e) => {
+  switch (e) {
+    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");
+  }
+}, pr = (e, s) => {
+  const { camera: t, rendering: n } = e, r = e.models[s], a = t.status === "permission-prompt" || t.status === "unknown";
+  return n.reason ? { supported: !1, reason: n.reason, needsPermission: a } : t.reason ? { supported: !1, reason: t.reason, needsPermission: a } : r != null && r.reason ? { supported: !1, reason: r.reason, needsPermission: a } : { supported: !0, reason: null, needsPermission: a };
+}, yr = (e) => {
+  const s = e instanceof Error ? e.message : String(e ?? ""), t = s.toLowerCase();
+  return t.includes("integrity") || t.includes("sha-384") || t.includes("sha384") ? I("model-integrity", s) : t.includes("failed to fetch") || t.includes("networkerror") || t.includes("load failed") || /\b(404|403|5\d\d)\b/.test(t) || t.includes("fetch") ? I("model-unreachable", s) : t.includes("webgl") || t.includes("gpu") ? I("webgl-unavailable", s) : s ? I("model-init-failed", s) : I("unknown");
+}, kt = (e) => {
+  switch (e instanceof DOMException ? e.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 e instanceof TypeError ? "unsupported" : "unknown";
+  }
+}, ct = {
+  "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."
+}, ze = () => ({
+  mediaDevices: typeof navigator < "u" ? navigator.mediaDevices : void 0,
+  permissions: typeof navigator < "u" ? navigator.permissions : void 0,
+  isSecureContext: typeof window < "u" ? window.isSecureContext : void 0
+}), xt = async (e = ze()) => {
+  var s;
+  if (!((s = e.permissions) != null && s.query)) return { state: "unknown", prompt: !1 };
+  try {
+    const t = await e.permissions.query({ name: "camera" });
+    return t.state === "granted" ? { state: "granted", prompt: !1 } : t.state === "denied" ? { state: "blocked", prompt: !1 } : { state: "unknown", prompt: t.state === "prompt" };
+  } catch {
+    return { state: "unknown", prompt: !1 };
+  }
+}, bt = (e, s) => e === "permission-denied" ? {
+  state: s === "blocked" ? "blocked" : "denied",
+  reason: I("camera-permission-denied")
+} : { state: "unavailable", reason: Ct(e) }, wr = async (e = {}, s = ze()) => {
+  var n;
+  if (s.isSecureContext === !1)
+    return {
+      state: "unavailable",
+      reason: I("camera-insecure-context"),
+      stream: null
+    };
+  const t = (n = s.mediaDevices) == null ? void 0 : n.getUserMedia;
+  if (typeof t != "function")
+    return {
+      state: "unavailable",
+      reason: I("camera-unsupported"),
+      stream: null
+    };
+  try {
+    const r = await t.call(
+      s.mediaDevices,
+      e.constraints ?? { video: { facingMode: "user" } }
+    );
+    return e.keepStream ? { state: "granted", reason: null, stream: r } : (r.getTracks().forEach((a) => a.stop()), { state: "granted", reason: null, stream: null });
+  } catch (r) {
+    const a = kt(r), c = await xt(s);
+    return { ...bt(a, c.state), stream: null };
+  }
+}, vr = async (e, s = ze()) => {
+  var t, n;
+  if (!((t = s.permissions) != null && t.query)) return () => {
+  };
+  try {
+    const r = await s.permissions.query({ name: "camera" }), a = () => {
+      r.state === "granted" ? e({ state: "granted", prompt: !1 }) : r.state === "denied" ? e({ state: "blocked", prompt: !1 }) : e({ state: "unknown", prompt: r.state === "prompt" });
+    };
+    return (n = r.addEventListener) == null || n.call(r, "change", a), () => {
+      var c;
+      return (c = r.removeEventListener) == null ? void 0 : c.call(r, "change", a);
+    };
+  } catch {
+    return () => {
+    };
+  }
+}, Sr = (e) => e === "unknown" || e === "denied" || e === "granted", Mr = {
+  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."
+}, Ns = (e, s, t = "cover", n = 1) => {
+  if (e.width <= 0 || e.height <= 0 || s.width <= 0 || s.height <= 0)
+    return null;
+  const r = Number.isFinite(n) && n > 0 ? n : 1, a = s.width / e.width, c = s.height / e.height, o = t === "contain" ? c <= a : c >= a, d = (o ? c : a) * r, l = o ? e.width * c * r : s.width * r, h = o ? s.height * r : e.height * a * r;
+  return {
+    scale: d,
+    drawWidth: l,
+    drawHeight: h,
+    offsetX: (s.width - l) / 2,
+    offsetY: (s.height - h) / 2
+  };
+}, Me = (e) => e === "webcam" || e === void 0, Us = ({
+  source: e,
+  feed: s,
+  zoom: t = 1,
+  mirrored: n = !1
+}) => {
+  const r = Ns(e, s, "cover", t);
+  return r ? { ...r, source: e, feed: s, zoom: Number.isFinite(t) && t > 0 ? t : 1, mirrored: n } : null;
+}, Cr = (e, s, t = { x: 0, y: 0 }) => {
+  const n = s.mirrored ? s.source.width - e.x : e.x;
+  return t.x = (s.offsetX + n * s.scale) / s.feed.width, t.y = (s.offsetY + e.y * s.scale) / s.feed.height, t;
+}, Bs = (e, s, t = { x: 0, y: 0 }) => {
+  const n = (e.x * s.feed.width - s.offsetX) / s.scale;
+  return t.x = s.mirrored ? s.source.width - n : n, t.y = (e.y * s.feed.height - s.offsetY) / s.scale, t;
+}, kr = (e, s) => {
+  const t = Bs(e, s);
+  return t.x >= 0 && t.x <= s.source.width && t.y >= 0 && t.y <= s.source.height;
+}, xr = (e, s = { x: 0, y: 0 }) => (s.x = 1 - e.x, s.y = e.y, e.z !== void 0 && (s.z = e.z), s), br = (e, s, t, n = { x: 0, y: 0 }) => {
+  switch (t) {
+    case 90:
+      return n.x = s.height - e.y, n.y = e.x, n;
+    case 180:
+      return n.x = s.width - e.x, n.y = s.height - e.y, n;
+    case 270:
+      return n.x = e.y, n.y = s.width - e.x, n;
+    default:
+      return n.x = e.x, n.y = e.y, n;
+  }
+}, Tr = (e, s) => s === 90 || s === 270 ? { width: e.height, height: e.width } : { width: e.width, height: e.height };
+class O extends Error {
+  constructor(s) {
+    super(s), this.name = "VincenttXRError";
+  }
+}
+class zs {
+  constructor(s) {
+    u(this, "options");
+    const t = {
+      verbose: !1,
+      prefix: z.loggerPrefix
+    };
+    this.options = { ...t, ...s };
+  }
+  log(...s) {
+    const { verbose: t, prefix: n } = this.options;
+    t && console.info(n, ...s);
+  }
+  error(...s) {
+    const { verbose: t, prefix: n } = this.options;
+    t && console.error(n, ...s);
+  }
+}
+const lt = new B.Vector3(), Pe = new B.Vector3(), Tt = (e, s, t, n, r) => {
+  lt.set(e, s, 0).unproject(t), Pe.copy(lt).sub(t.position).normalize();
+  const a = (n - t.position.z) / Pe.z;
+  return r.copy(t.position).addScaledVector(Pe, a);
+}, Ws = (e, s, t = new B.Vector3(), n = 0) => Tt((e.x - 0.5) * 2, (0.5 - e.y) * 2, s, n, t), Er = (e, s, t = new B.Vector3(), n = 0) => Tt(e.x, e.y, s, n, t), X = new B.Vector3(), Ar = (e, s, t = { x: 0, y: 0, z: 0 }) => (X.set(e.x, e.y, e.z).project(s), t.x = X.x / 2 + 0.5, t.y = 0.5 - X.y / 2, t.z = X.z, t), Rr = (e, s, t = { x: 0, y: 0, z: 0 }) => (X.set(e.x, e.y, e.z).project(s), t.x = X.x, t.y = X.y, t.z = X.z, t), De = (e, s, t) => Ws(e, s, t, 0), qs = (e, s, t = 0.2) => t * s + (1 - t) * e;
+class me {
+  constructor(s) {
+    u(this, "canvas");
+    u(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 t = s.width, n = s.height, r = Math.min(
+      1,
+      this.maxDimension * this.scale / Math.max(t, n)
+    );
+    if (r >= 1) return s;
+    const a = Math.max(1, Math.round(t * r)), c = Math.max(1, Math.round(n * r));
+    (!this.canvas || this.canvas.width !== a || this.canvas.height !== c) && (this.canvas = new OffscreenCanvas(a, c));
+    const o = this.canvas.getContext("2d");
+    return o ? (o.setTransform(1, 0, 0, 1, 0, 0), o.clearRect(0, 0, a, c), o.drawImage(s, 0, 0, a, c), this.canvas) : s;
+  }
+  dispose() {
+    this.canvas = void 0;
+  }
+}
+const Vs = {
+  "/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",
+  // v3: canonical-frame head (first 468 vertices = the canonical face landmarks),
+  // authored in assets-src/head-occluder/head-occluder-v3.blend. Hash of the
+  // exported GLB; the CDN copy must be byte-identical to example/src/assets/models.
+  "/assets/xr/3d-models/head-occluder-v3.glb": "sha384-bmKKYb7k1qsGqkOSUBwv3oqI9eOche97/OvRxXDxrqZAgqpy+4PJ5HU9O94lrjFO",
+  // Shoulder / upper-torso occluder in the canonical torso frame (same .blend).
+  "/assets/xr/3d-models/shoulder-occluder-v1.glb": "sha384-iXxOvC+IoXfgpf8S/JSsV6lLzzLs6vtmaslJy7R0iLtl5Yb17U+/ATfGdhpmamae",
+  // 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 Ks(e, s) {
+  const t = await fetch(e, s != null && s.signal ? { signal: s.signal } : void 0);
+  if (!t.ok)
+    throw new Error(`fetchAndVerify: ${t.status} ${e}`);
+  const n = await t.arrayBuffer(), r = Ys(e);
+  if (!r) {
+    if (Gs(e))
+      throw new Error(`[xr-sdk integrity] no SRI hash for SDK asset ${e}`);
+    return console.warn(`[xr-sdk integrity] no SRI hash for ${e} — passing through`), n;
+  }
+  const a = await js(n);
+  if (a !== r)
+    throw new Error(
+      `[xr-sdk integrity] SRI mismatch for ${e}: expected ${r}, got ${a}`
+    );
+  return n;
+}
+function Gs(e) {
+  try {
+    return new URL(e).origin === new URL(z.assetStorageEndpoint).origin;
+  } catch {
+    return !1;
+  }
+}
+async function Z(e) {
+  const s = await Ks(e);
+  return new Uint8Array(s);
+}
+const ie = /* @__PURE__ */ new Map();
+function Xs(e) {
+  let s = ie.get(e);
+  if (!s) {
+    const r = { bytes: Z(e), holders: 0 };
+    r.bytes.catch(() => {
+      ie.get(e) === r && ie.delete(e);
+    }), ie.set(e, r), s = r;
+  }
+  const t = s;
+  t.holders += 1;
+  let n = !1;
+  return {
+    bytes: t.bytes,
+    release: () => {
+      n || (n = !0, t.holders -= 1, t.holders <= 0 && ie.get(e) === t && ie.delete(e));
+    }
+  };
+}
+function Ys(e) {
+  try {
+    const s = new URL(e);
+    return Vs[s.pathname];
+  } catch {
+    return;
+  }
+}
+async function js(e) {
+  const s = await crypto.subtle.digest("SHA-384", e), t = new Uint8Array(s);
+  let n = "";
+  for (let r = 0; r < t.byteLength; r++)
+    n += String.fromCharCode(t[r]);
+  return `sha384-${btoa(n)}`;
+}
+const Le = /* @__PURE__ */ new Map();
+function J(e) {
+  const s = e.wasmBinaryPath;
+  let t = Le.get(s);
+  return t || (t = Qs(s).catch(() => {
+    Le.delete(s);
+  }), Le.set(s, t)), t;
+}
+async function Qs(e) {
+  const s = await fetch(e, { credentials: "same-origin" });
+  if (!s.ok || !s.body)
+    throw new Error(`warmVisionWasm: ${s.status} ${e}`);
+  const t = s.body.getReader();
+  for (; ; ) {
+    const { done: n } = await t.read();
+    if (n) return;
+  }
+}
+class $ {
+  constructor() {
+    u(this, "disposed", !1);
+    u(this, "paused", !1);
+    u(this, "rafId", null);
+    // Inference bookkeeping behind `getDiagnostics()`. Subclasses call
+    // `recordInference(startMs)` right after their detect call and
+    // `recordDetections(count, confidence)` after reading the result.
+    u(this, "statInferenceMs", null);
+    u(this, "statInferences", 0);
+    u(this, "statWindowStart", 0);
+    u(this, "statWindowCount", 0);
+    u(this, "statFps", 0);
+    u(this, "statSkipped", 0);
+    u(this, "statDetections", null);
+    u(this, "statConfidence", null);
+    u(this, "statStatus", "ready");
+    u(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.
+    u(this, "targetFrameIntervalMs", 0);
+    u(this, "lastInferenceMs", 0);
+    /** Analysis-resolution multiplier (0.25..1) from the quality tier; subclasses read it where they downscale. */
+    u(this, "analysisScale", 1);
+  }
+  /** Record one completed inference that started at `startMs` (`performance.now()`). */
+  recordInference(s, t = performance.now()) {
+    const n = t - s;
+    this.statInferenceMs = n, this.statInferences += 1, this.statWindowCount += 1, this.statWindowStart === 0 && (this.statWindowStart = t);
+    const r = t - this.statWindowStart;
+    return r >= 1e3 && (this.statFps = this.statWindowCount * 1e3 / r, this.statWindowStart = t, this.statWindowCount = 0), n;
+  }
+  /** Record what the last inference found (subjects and the primary confidence). */
+  recordDetections(s, t = null) {
+    this.statDetections = s, this.statConfidence = t;
+  }
+  /** 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 Zs = 768;
+class Js extends $ {
+  constructor() {
+    super();
+    u(this, "landmarker", null);
+    u(this, "processingTime", null);
+    u(this, "coordinates");
+    u(this, "visibility");
+    u(this, "sourceCanvas");
+    u(this, "downscaler", new me(Zs));
+  }
+  async getBodyData() {
+    if (!this.landmarker || !this.sourceCanvas)
+      return;
+    const t = this.downscaler.draw(this.sourceCanvas), n = performance.now(), r = this.landmarker.detectForVideo(t, n), a = performance.now();
+    this.processingTime = a - n, this.recordInference(n, a);
+    const c = r.landmarks, o = c == null ? void 0 : c[0];
+    this.recordDetections(
+      (c == null ? void 0 : c.length) ?? 0,
+      o && o.length ? o.reduce((h, m) => h + (m.visibility ?? 0), 0) / o.length : null
+    );
+    const d = [], l = [];
+    if (c)
+      return c.forEach((h, m) => {
+        d[m] || (d[m] = [], l[m] = []), h.forEach((y) => {
+          d[m].push(ue(y)), l[m].push(y.visibility ?? 1);
+        });
+      }), {
+        coordinatesList: d,
+        visibilityList: l
+      };
+  }
+  async processBodyTracking() {
+    if (!(this.disposed || this.paused || !this.landmarker)) {
+      if (this.shouldRunInference()) {
+        const t = await this.getBodyData();
+        t && (this.coordinates = t.coordinatesList, this.visibility = t.visibilityList);
+      }
+      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, this.visibility = void 0;
+  }
+  getLandmarks2D(t = 0) {
+    if (this.coordinates)
+      return this.coordinates[t];
+  }
+  getVisibility(t = 0) {
+    var n;
+    return (n = this.visibility) == null ? void 0 : n[t];
+  }
+  async initialize(t) {
+    const n = await Q.forVisionTasks(
+      new URL("/assets/xr/wasm", z.assetStorageEndpoint).toString()
+    ), [r] = await Promise.all([
+      Z(
+        new URL("/assets/xr/models/body_tracking.task", z.assetStorageEndpoint).toString()
+      ),
+      J(n)
+    ]);
+    this.landmarker = await ms.createFromOptions(n, {
+      baseOptions: {
+        modelAssetBuffer: r,
+        delegate: "GPU"
+      },
+      runningMode: "VIDEO",
+      numPoses: (t == null ? void 0 : t.numPoses) || 1
+    });
+  }
+  async run({ sourceCanvas: t, targetFps: n, analysisScale: r }) {
+    this.setAnalysisScale(r), this.downscaler.setScale(this.analysisScale), this.sourceCanvas = t, this.setTargetFps(n), this.rafId === null && await this.processBodyTracking();
+  }
+  getModelNode() {
+    return {
+      getLandmarks2D: this.getLandmarks2D.bind(this),
+      getVisibility: this.getVisibility.bind(this)
+    };
+  }
+  async getPerformanceData() {
+    return {
+      name: this.constructor.name,
+      processingTime: this.processingTime
+    };
+  }
+}
+const Et = Symbol("xr.modelNodeSource"), Fr = (e) => e[Et] ?? e, $s = 0.11, en = 4e-3, tn = "/assets/xr/models/face_tracking.task", sn = "/assets/xr/wasm", nn = (e, s, t = !0) => t ? s.set(e.x, -e.y, e.z) : s.set(e.x, e.y, -e.z), rn = (e, s) => s.setFromRotationMatrix(e).normalize();
+class an extends $ {
+  constructor() {
+    super();
+    u(this, "landmarker", null);
+    /** The face model bytes, held while this model is alive (shared with the still-image detector). */
+    u(this, "modelBytes", null);
+    u(this, "processingTime", null);
+    u(this, "sourceCanvas");
+    u(this, "analysisCanvas");
+    u(this, "getSource");
+    u(this, "detectionResults");
+    u(this, "numFaces", 1);
+    u(this, "cameras", []);
+    // camera object to unproject each face's translation
+    u(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.
+    u(this, "leftCheekScratch", []);
+    u(this, "rightCheekScratch", []);
+    // Reused per-frame rotation scratch (matrix -> quaternion -> mirror -> euler),
+    // allocated once to avoid per-frame churn at 30+ fps.
+    u(this, "rotMatrixScratch", new B.Matrix4());
+    u(this, "rotQuatScratch", new B.Quaternion());
+    u(this, "rotEulerScratch", new B.Euler());
+  }
+  extractAndUpdateFaceData(t) {
+    var a;
+    if (!t.faceLandmarks.length) {
+      this.faces = [];
+      return;
+    }
+    const n = t.faceLandmarks.length;
+    this.faces.length > n && (this.faces.length = n, this.leftCheekScratch.length = n, this.rightCheekScratch.length = n);
+    const r = Me((a = this.getSource) == null ? void 0 : a.call(this));
+    for (; this.faces.length < n; )
+      this.faces.push({
+        transform: {
+          position: new B.Vector3(),
+          rotation: new B.Vector3(),
+          quaternion: new B.Quaternion(),
+          scale: new B.Vector3()
+        },
+        gestures: {},
+        mirrored: r
+      }), this.leftCheekScratch.push(new B.Vector3()), this.rightCheekScratch.push(new B.Vector3());
+    for (let c = 0; c < n; c += 1)
+      this.faces[c].mirrored = r;
+    for (let c = 0; c < n; c += 1) {
+      if (!this.cameras[c])
+        continue;
+      const o = this.faces[c], d = t.faceLandmarks[c], l = t.facialTransformationMatrixes[c];
+      this.rotMatrixScratch.fromArray(l.data), rn(this.rotMatrixScratch, o.transform.quaternion), this.rotQuatScratch.copy(o.transform.quaternion), this.rotQuatScratch.set(
+        -this.rotQuatScratch.x,
+        this.rotQuatScratch.y,
+        this.rotQuatScratch.z,
+        this.rotQuatScratch.w
+      ), this.rotEulerScratch.setFromQuaternion(this.rotQuatScratch, "XYZ"), nn(this.rotEulerScratch, o.transform.rotation, r), De(d[4], this.cameras[c], o.transform.position), De(d[50], this.cameras[c], this.leftCheekScratch[c]), De(d[280], this.cameras[c], this.rightCheekScratch[c]);
+      const m = this.leftCheekScratch[c].distanceTo(this.rightCheekScratch[c]) * $s, y = Math.abs(B.MathUtils.radToDeg(this.rotEulerScratch.y)), S = m + y * en, M = o.transform.scale.x, C = qs(
+        isNaN(M) ? 0 : M,
+        S
+      );
+      o.transform.scale.set(C, C, C);
+      const E = o.gestures, _ = t.faceBlendshapes[c].categories;
+      for (const g of _)
+        E[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 t = on(this.numFaces) * this.analysisScale, n = this.sourceCanvas.width, r = this.sourceCanvas.height, a = Math.min(1, t / Math.max(n, r)), c = Math.max(1, Math.round(n * a)), o = Math.max(1, Math.round(r * a));
+    (!this.analysisCanvas || this.analysisCanvas.width !== c || this.analysisCanvas.height !== o) && (this.analysisCanvas = new OffscreenCanvas(c, o));
+    const d = this.analysisCanvas.getContext("2d");
+    if (!d) {
+      this.rafId = requestAnimationFrame(this.processFaceTracking.bind(this));
+      return;
+    }
+    d.setTransform(1, 0, 0, 1, 0, 0), d.clearRect(0, 0, c, o), d.drawImage(this.sourceCanvas, 0, 0, c, o);
+    const l = performance.now(), h = this.landmarker.detectForVideo(this.analysisCanvas, l), m = performance.now();
+    this.processingTime = m - l, this.recordInference(l, m), this.recordDetections(h.faceLandmarks.length, null), this.detectionResults = h, this.extractAndUpdateFaceData(h), !(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.releaseModelBytes(), this.sourceCanvas = void 0, this.getSource = void 0, this.analysisCanvas = void 0, this.detectionResults = void 0, this.processingTime = null, this.cameras = [], this.faces = [], this.leftCheekScratch = [], this.rightCheekScratch = [];
+  }
+  getFace(t = 0) {
+    return this.faces[t];
+  }
+  getDetectionResults() {
+    return this.detectionResults;
+  }
+  getRawFaceTrackingData(t = 0) {
+    var n, r, a, c;
+    if (this.detectionResults)
+      return {
+        landmarks: (n = this.detectionResults.faceLandmarks) == null ? void 0 : n[t],
+        blendshapes: (a = (r = this.detectionResults.faceBlendshapes) == null ? void 0 : r[t]) == null ? void 0 : a.categories,
+        transformationMatrix: (c = this.detectionResults.facialTransformationMatrixes) == null ? void 0 : c[t]
+      };
+  }
+  async initialize(t) {
+    var c;
+    this.numFaces = (t == null ? void 0 : t.numFaces) || 1;
+    const n = await Q.forVisionTasks(
+      new URL(sn, z.assetStorageEndpoint).toString()
+    );
+    (c = this.modelBytes) == null || c.release();
+    const r = Xs(
+      new URL(tn, z.assetStorageEndpoint).toString()
+    );
+    this.modelBytes = r;
+    let a;
+    try {
+      const [o] = await Promise.all([r.bytes, J(n)]);
+      a = await fs.createFromOptions(n, {
+        baseOptions: {
+          modelAssetBuffer: o,
+          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
+      });
+    } catch (o) {
+      throw this.releaseModelBytes(r), o;
+    }
+    if (this.disposed) {
+      a.close(), this.releaseModelBytes(r);
+      return;
+    }
+    this.landmarker = a;
+  }
+  releaseModelBytes(t = this.modelBytes) {
+    t == null || t.release(), this.modelBytes === t && (this.modelBytes = null);
+  }
+  async run({
+    sourceCanvas: t,
+    getSource: n,
+    targetFps: r,
+    analysisScale: a
+  }) {
+    this.sourceCanvas = t, this.getSource = n, this.setTargetFps(r), this.setAnalysisScale(a), this.analysisCanvas = void 0, this.rafId === null && this.processFaceTracking();
+  }
+  getModelNode() {
+    const t = this, n = {
+      get detectionResults() {
+        return t.detectionResults;
+      },
+      get numFaces() {
+        return t.numFaces;
+      },
+      getDetectionResults: this.getDetectionResults.bind(this),
+      getFace: this.getFace.bind(this),
+      getRawFaceTrackingData: this.getRawFaceTrackingData.bind(this),
+      setCamera: (r, a = 0) => {
+        this.cameras[a] = r;
+      }
+    };
+    return Object.defineProperty(n, Et, { value: t }), n;
+  }
+  async getPerformanceData() {
+    return {
+      name: this.constructor.name,
+      processingTime: this.processingTime
+    };
+  }
+}
+const on = (e) => e > 1 ? 1024 : 512;
+var G = /* @__PURE__ */ ((e) => (e.ClosedFist = "closed_fist", e.OpenPalm = "open_palm", e.PointingUp = "pointing_up", e.ThumbDown = "thumb_down", e.ThumbUp = "thumb_up", e.Victory = "victory", e.ILoveYou = "i_love_you", e.None = "none", e))(G || {});
+const cn = 512, ln = {
+  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
+}, dn = 15;
+class hn extends $ {
+  constructor() {
+    super();
+    u(this, "landmarker", null);
+    u(this, "processingTime", null);
+    u(this, "coordinates");
+    u(this, "gesture");
+    u(this, "sourceCanvas");
+    u(this, "downscaler", new me(cn));
+  }
+  async getGestureData() {
+    var d, l;
+    if (!this.landmarker || !this.sourceCanvas)
+      return;
+    const t = this.downscaler.draw(this.sourceCanvas), n = performance.now(), r = this.landmarker.recognizeForVideo(t, n), a = performance.now();
+    this.processingTime = a - n, this.recordInference(n, a), this.recordDetections(r.landmarks.length, ((l = (d = r.gestures[0]) == null ? void 0 : d[0]) == null ? void 0 : l.score) ?? null);
+    const c = r.landmarks[0], o = [];
+    if (c) {
+      const h = r.gestures[0][0].categoryName;
+      return c.forEach((m) => {
+        o.push(ue(m));
+      }), {
+        coordinates: o,
+        gesture: ln[h]
+      };
+    }
+    return { coordinates: void 0, gesture: void 0 };
+  }
+  async processGestureTracking() {
+    if (!this.disposed) {
+      if (this.shouldRunInference()) {
+        const t = await this.getGestureData();
+        t && (this.coordinates = t.coordinates, this.gesture = t.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 t = await Q.forVisionTasks(
+      new URL("/assets/xr/wasm", z.assetStorageEndpoint).toString()
+    ), [n] = await Promise.all([
+      Z(
+        new URL(
+          "/assets/xr/models/gesture_tracking.task",
+          z.assetStorageEndpoint
+        ).toString()
+      ),
+      J(t)
+    ]), r = await gs.createFromOptions(t, {
+      baseOptions: {
+        modelAssetBuffer: n,
+        delegate: "GPU"
+      },
+      runningMode: "VIDEO",
+      numHands: 1
+    });
+    this.landmarker = r;
+  }
+  async run({ sourceCanvas: t, targetFps: n, analysisScale: r }) {
+    this.setAnalysisScale(r), this.downscaler.setScale(this.analysisScale), this.sourceCanvas = t, this.setTargetFps(n ?? dn), this.rafId === null && await this.processGestureTracking();
+  }
+  getModelNode() {
+    const t = this;
+    return {
+      get coordinates() {
+        return t.coordinates;
+      },
+      get gesture() {
+        return t.gesture;
+      }
+    };
+  }
+  async getPerformanceData() {
+    return {
+      name: this.constructor.name,
+      processingTime: this.processingTime
+    };
+  }
+}
+class un extends $ {
+  constructor() {
+    super();
+    u(this, "landmarker", null);
+    u(this, "status", "loading");
+    u(this, "error", null);
+    u(this, "processingTime", null);
+    u(this, "sourceCanvas");
+    u(this, "getSource");
+    u(this, "downscaler", new me(Ne().analysisMaxDimension));
+    u(this, "raw");
+    u(this, "delegatePolicy", "auto");
+    u(this, "delegate", "GPU");
+    /** Kept so the graph can be rebuilt on another delegate without refetching. */
+    u(this, "vision", null);
+    u(this, "modelBuffer", null);
+    u(this, "graphOptions", {});
+    u(this, "rebuilding", !1);
+    u(this, "fallbackAttempted", !1);
+    u(this, "result", xs());
+    u(this, "builder", new Ts());
+    u(this, "node");
+    this.node = {
+      getResult: () => this.result,
+      getRawResult: () => this.raw,
+      getStatus: () => this.status,
+      getError: () => this.error,
+      getDelegate: () => this.delegate,
+      setOptions: (t) => this.setRuntimeOptions(t)
+    };
+  }
+  setRuntimeOptions(t) {
+    const n = this.builder.getOptions().analysisMaxDimension;
+    this.builder.setOptions(t);
+    const r = this.builder.getOptions().analysisMaxDimension;
+    r !== n && (this.downscaler.dispose(), this.downscaler = new me(r), this.downscaler.setScale(this.analysisScale));
+  }
+  async initialize(t) {
+    this.status = "loading", this.error = null, this.setRuntimeOptions(t ?? {});
+    try {
+      const n = await Q.forVisionTasks(
+        new URL("/assets/xr/wasm", z.assetStorageEndpoint).toString()
+      ), [r] = await Promise.all([
+        Z((t == null ? void 0 : t.modelUrl) ?? vt),
+        J(n)
+      ]);
+      this.vision = n, this.modelBuffer = r, this.graphOptions = {
+        runningMode: "VIDEO",
+        outputFaceBlendshapes: (t == null ? void 0 : t.outputFaceBlendshapes) ?? !0,
+        minFaceDetectionConfidence: t == null ? void 0 : t.minFaceDetectionConfidence,
+        minFacePresenceConfidence: t == null ? void 0 : t.minFacePresenceConfidence,
+        minPoseDetectionConfidence: t == null ? void 0 : t.minPoseDetectionConfidence,
+        minPosePresenceConfidence: t == null ? void 0 : t.minPosePresenceConfidence,
+        minHandLandmarksConfidence: t == null ? void 0 : t.minHandLandmarksConfidence
+      }, this.delegatePolicy = (t == null ? void 0 : t.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(t) {
+    if (!this.vision || !this.modelBuffer)
+      throw new Error("HolisticTrackingModel: initialize() has not loaded the model");
+    return ps.createFromOptions(this.vision, {
+      baseOptions: { modelAssetBuffer: this.modelBuffer, delegate: t },
+      ...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(t) {
+    this.fallbackAttempted = !0, this.rebuilding = !0, this.status = "loading", console.warn(
+      "[xr-sdk holistic] GPU inference failed; rebuilding the graph on the CPU delegate.",
+      t.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, c, o, d;
+    if (!this.landmarker || !this.sourceCanvas) return;
+    const t = this.downscaler.draw(this.sourceCanvas), n = performance.now();
+    try {
+      this.raw = this.landmarker.detectForVideo(t, n), this.status === "error" && (this.status = "ready", this.error = null), this.recordInferenceError(null);
+      const l = this.raw, h = ((r = l.faceLandmarks) != null && r.length ? 1 : 0) + ((a = l.leftHandLandmarks) != null && a.length ? 1 : 0) + ((c = l.rightHandLandmarks) != null && c.length ? 1 : 0) + ((o = l.poseLandmarks) != null && o.length ? 1 : 0), m = (d = l.poseLandmarks) == null ? void 0 : d[0];
+      this.recordDetections(
+        h,
+        m && m.length ? m.reduce((y, S) => y + (S.visibility ?? 0), 0) / m.length : null
+      );
+    } catch (l) {
+      const h = l instanceof Error ? l : new Error(String(l));
+      this.delegatePolicy === "auto" && this.delegate === "GPU" && !this.fallbackAttempted ? this.fallbackToCpu(h) : (this.status = "error", this.error = h, this.recordInferenceError(h));
+    }
+    this.processingTime = performance.now() - n, this.recordInference(n);
+  }
+  /** The session mirrors only the webcam feed (an unknown kind is treated as webcam). */
+  isMirrored() {
+    var t;
+    return Me((t = this.getSource) == null ? void 0 : t.call(this));
+  }
+  async run({
+    sourceCanvas: t,
+    getSource: n,
+    targetFps: r,
+    analysisScale: a
+  }) {
+    this.sourceCanvas = t, 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 mn = (e) => e === "left" ? "right" : "left", fn = (e, s) => s ? mn(e) : e, gn = /left|right|Left|Right/, pn = {
+  left: "right",
+  right: "left",
+  Left: "Right",
+  Right: "Left"
+}, yn = (e) => e.replace(gn, (s) => pn[s]), Ir = (e, s) => s ? yn(e) : e, _r = (e) => e ? -1 : 1, wn = [
+  "wrist",
+  "thumbCmc",
+  "thumbMcp",
+  "thumbIp",
+  "thumbTip",
+  "indexMcp",
+  "indexPip",
+  "indexDip",
+  "indexTip",
+  "middleMcp",
+  "middlePip",
+  "middleDip",
+  "middleTip",
+  "ringMcp",
+  "ringPip",
+  "ringDip",
+  "ringTip",
+  "pinkyMcp",
+  "pinkyPip",
+  "pinkyDip",
+  "pinkyTip"
+], Pr = Object.fromEntries(
+  wn.map((e, s) => [e, s])
+), vn = 200, le = (e, s) => Math.hypot(e.x - s.x, e.y - s.y), de = (e) => e === "left" ? "right" : "left", Oe = (e, s, t) => ({
+  handedness: s,
+  score: e.score,
+  world: e.world,
+  image: e.image,
+  timestampMs: t,
+  held: !1
+}), Sn = (e, s, t, {
+  holdMs: n = vn,
+  confidentScore: r = 0.8,
+  continuityMs: a = 500
+} = {}) => {
+  const c = (l) => !!l && t - l.timestampMs <= a && l.image.length > 0, o = { left: null, right: null }, d = e.filter((l) => l.image.length > 0).slice(0, 2);
+  if (d.length === 2) {
+    const [l, h] = d, m = l.handedness !== void 0 && h.handedness !== void 0 && l.handedness !== h.handedness, y = l.score >= r && h.score >= r;
+    let S;
+    if (m && y)
+      S = l.handedness;
+    else if (c(s.left) && c(s.right)) {
+      const M = le(l.image[0], s.left.image[0]) + le(h.image[0], s.right.image[0]), C = le(l.image[0], s.right.image[0]) + le(h.image[0], s.left.image[0]);
+      S = M <= C ? "left" : "right";
+    } else if (m)
+      S = l.handedness;
+    else {
+      const M = l.score >= h.score ? l : h, C = M.handedness ?? "right";
+      S = M === l ? C : de(C);
+    }
+    o[S] = Oe(l, S, t), o[de(S)] = Oe(h, de(S), t);
+  } else if (d.length === 1) {
+    const [l] = d;
+    let h = l.handedness ?? "right";
+    if (l.score < r || l.handedness === void 0) {
+      const m = (M) => c(M) ? le(l.image[0], M.image[0]) : 1 / 0, y = m(s[h]);
+      m(s[de(h)]) < y && (h = de(h));
+    }
+    o[h] = Oe(l, h, t);
+  }
+  for (const l of ["left", "right"]) {
+    const h = s[l];
+    o[l] || !h || t - h.timestampMs <= n && (o[l] = { ...h, held: !0 });
+  }
+  return o;
+}, Mn = (e, s) => {
+  const t = e == null ? void 0 : e.toLowerCase();
+  if (!(t !== "left" && t !== "right"))
+    return fn(t, s);
+}, Cn = (e, s = { x: 0, y: 0, z: 0 }) => (s.x = e.x * 100, s.y = -e.y * 100, s.z = -e.z * 100, s), kn = 512, xn = Object.freeze({
+  minHandDetectionConfidence: 0.5,
+  minHandPresenceConfidence: 0.65,
+  minTrackingConfidence: 0.5
+});
+class bn extends $ {
+  constructor() {
+    super();
+    u(this, "landmarker", null);
+    u(this, "processingTime", null);
+    u(this, "hands");
+    u(this, "coordinates");
+    u(this, "gesture");
+    u(this, "handedness");
+    u(this, "poses", { left: null, right: null });
+    u(this, "sourceCanvas");
+    u(this, "getSource");
+    u(this, "downscaler", new me(kn));
+  }
+  async getHandData() {
+    var m, y, S;
+    if (!this.landmarker || !this.sourceCanvas)
+      return;
+    const t = this.downscaler.draw(this.sourceCanvas), n = performance.now(), r = this.landmarker.detectForVideo(t, n), a = performance.now();
+    this.processingTime = a - n, this.recordInference(n, a);
+    const c = [], o = [], d = r.handedness ?? r.handednesses ?? [];
+    this.recordDetections(r.landmarks.length, ((y = (m = d[0]) == null ? void 0 : m[0]) == null ? void 0 : y.score) ?? null);
+    const l = Me((S = this.getSource) == null ? void 0 : S.call(this));
+    if (r.landmarks.forEach((M, C) => {
+      var H, T;
+      if (!M || M.length === 0)
+        return;
+      const E = M.map(
+        (U) => ue(U)
+      ), _ = (((H = r.worldLandmarks) == null ? void 0 : H[C]) ?? []).map(
+        (U) => Cn(U)
+      ), g = (T = d[C]) == null ? void 0 : T[0], v = Mn(g == null ? void 0 : g.categoryName, l), w = (g == null ? void 0 : g.score) ?? 0, x = M[0].z < 0 ? "closed_fist" : "open_palm";
+      c.push({ coordinates: E, worldCoordinates: _, gesture: x, handedness: v, handednessScore: w }), o.push({
+        handedness: v,
+        score: w,
+        world: _,
+        image: E
+      });
+    }), this.poses = Sn(o, this.poses, n), !c.length)
+      return {
+        hands: void 0,
+        coordinates: void 0,
+        gesture: void 0,
+        handedness: void 0
+      };
+    const h = c[0];
+    return {
+      hands: c,
+      coordinates: h.coordinates,
+      gesture: h.gesture,
+      handedness: h.handedness
+    };
+  }
+  async processHandTracking() {
+    if (!this.disposed) {
+      if (this.shouldRunInference()) {
+        const t = await this.getHandData();
+        t && (this.hands = t.hands, this.coordinates = t.coordinates, this.gesture = t.gesture, this.handedness = t.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.getSource = void 0, this.hands = void 0, this.poses = { left: null, right: null }, this.downscaler.dispose(), this.coordinates = void 0, this.gesture = void 0, this.handedness = void 0;
+  }
+  async initialize() {
+    const t = await Q.forVisionTasks(
+      new URL("/assets/xr/wasm", z.assetStorageEndpoint).toString()
+    ), [n] = await Promise.all([
+      Z(
+        new URL("/assets/xr/models/hand_tracking.task", z.assetStorageEndpoint).toString()
+      ),
+      J(t)
+    ]), r = await ys.createFromOptions(t, {
+      baseOptions: {
+        modelAssetBuffer: n,
+        delegate: "GPU"
+      },
+      runningMode: "VIDEO",
+      numHands: 2,
+      ...xn
+    });
+    this.landmarker = r;
+  }
+  async run({
+    sourceCanvas: t,
+    getSource: n,
+    targetFps: r,
+    analysisScale: a
+  }) {
+    this.getSource = n, this.setAnalysisScale(a), this.downscaler.setScale(this.analysisScale), this.sourceCanvas = t, this.setTargetFps(r), this.rafId === null && await this.processHandTracking();
+  }
+  getModelNode() {
+    const t = this;
+    return {
+      get hands() {
+        return t.hands;
+      },
+      get coordinates() {
+        return t.coordinates;
+      },
+      get gesture() {
+        return t.gesture;
+      },
+      get handedness() {
+        return t.handedness;
+      },
+      get poses() {
+        return t.poses;
+      },
+      getHandPose: (n) => t.poses[n]
+    };
+  }
+  async getPerformanceData() {
+    return {
+      name: this.constructor.name,
+      processingTime: this.processingTime
+    };
+  }
+}
+const Tn = 24, En = 720, An = [
+  [255, 255, 255, 255],
+  // 0: background → green 255, kept
+  [0, 0, 0, 0]
+  // 1: person → green 0, discarded
+];
+class Rn extends $ {
+  constructor() {
+    super();
+    u(this, "segmenter", null);
+    u(this, "processingTime", null);
+    u(this, "sourceCanvas");
+    // input source canvas
+    u(this, "processCanvas");
+    // downscaled canvas of sourceCanvas for processing
+    u(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.
+    u(this, "inputSource");
+    u(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.)
+    u(this, "glCanvas");
+    u(this, "drawingUtils");
+    u(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.
+    u(this, "maskImageData");
+    u(this, "maskCanvas", null);
+    u(this, "segmentationMaskTexture");
+    u(this, "isMaskSetup", !1);
+    u(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.
+    u(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.
+    u(this, "rawCache", null);
+    /** When the frame behind `latestMask` was segmented (`performance.now()`). */
+    u(this, "latestMaskTimeMs", 0);
+    u(this, "quality", "medium");
+    u(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(t) {
+    this.inputSource = t, this.inputSourceSize = t ? this.readIntrinsicSize(t) : void 0;
+  }
+  readIntrinsicSize(t) {
+    if (t instanceof HTMLVideoElement)
+      return t.videoWidth > 0 ? { width: t.videoWidth, height: t.videoHeight } : void 0;
+    if (t instanceof HTMLImageElement)
+      return t.naturalWidth > 0 ? { width: t.naturalWidth, height: t.naturalHeight } : void 0;
+    const n = t.width, r = t.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 t = this.readIntrinsicSize(this.inputSource);
+    if (!t) return;
+    this.inputSourceSize = t;
+    const n = Math.min(1, En / Math.max(t.width, t.height)), r = Math.max(1, Math.round(t.width * n)), a = Math.max(1, Math.round(t.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 t = this.inputSource ?? this.sourceCanvas;
+    if (!this.segmenter || !t) {
+      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 d = this.processCanvas.width, l = this.processCanvas.height;
+      if (r.clearRect(0, 0, d, l), this.inputSource && this.inputSourceSize) {
+        const { width: h, height: m } = this.inputSourceSize, y = Math.min(d / h, l / m), S = h * y, M = m * y;
+        r.drawImage(this.inputSource, (d - S) / 2, (l - M) / 2, S, M);
+      } else
+        r.drawImage(t, 0, 0, d, l);
+    }
+    const a = performance.now(), o = this.segmenter.segmentForVideo(this.processCanvas, a).categoryMask;
+    if (!o) {
+      if (this.disposed || this.paused) return;
+      this.rafId = requestAnimationFrame(this.processSegmentation.bind(this));
+      return;
+    }
+    if (this.rawCache = null, this.latestMaskTimeMs = a, this.latestMask && (this.latestMask.close(), this.latestMask = null), this.useGpuMaskPath && this.drawingUtils && this.glCanvas)
+      this.drawingUtils.drawCategoryMask(o, An), this.latestMask = o.clone(), o.close(), this.blitGlToMask();
+    else {
+      this.latestMask = o.clone();
+      const d = this.readMaskToImageData(o);
+      o.close(), d && this.blitImageDataToMask(d);
+    }
+    this.segmentationMaskTexture && (this.isMaskSetup || (this.segmentationMaskTexture.format = yt, this.segmentationMaskTexture.minFilter = ve, this.segmentationMaskTexture.magFilter = ve, 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 t = this.maskCanvas.getContext("2d"), n = this.filterCanvas.getContext("2d");
+    !t || !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), t.clearRect(0, 0, this.maskCanvas.width, this.maskCanvas.height), t.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(t) {
+    const n = t.getAsUint8Array(), { width: r, height: a } = t;
+    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 c = this.maskImageData.data;
+    for (let o = 0; o < n.length; o += 1) {
+      const d = n[o] === 255 ? 0 : 255;
+      c[o * 4] = 255, c[o * 4 + 1] = d, c[o * 4 + 2] = 255, c[o * 4 + 3] = d;
+    }
+    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(t) {
+    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(t.width, t.height), c = a.getContext("2d");
+    c && (c.putImageData(t, 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(t, n) {
+    return this.stagingCanvas || (this.stagingCanvas = document.createElement("canvas")), this.stagingCanvas.width !== t && (this.stagingCanvas.width = t), 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(t) {
+    this.quality = (t == null ? void 0 : t.quality) ?? "low";
+    const n = await Q.forVisionTasks(
+      new URL("/assets/xr/wasm", z.assetStorageEndpoint).toString()
+    ), [r] = await Promise.all([
+      Z(
+        new URL("/assets/xr/models/segmentation.tflite", z.assetStorageEndpoint).toString()
+      ),
+      J(n)
+    ]);
+    this.glCanvas = new OffscreenCanvas(1, 1);
+    const a = this.glCanvas.getContext("webgl2", {
+      preserveDrawingBuffer: !0
+    });
+    this.segmenter = await pt.createFromOptions(n, {
+      baseOptions: {
+        modelAssetBuffer: r,
+        delegate: "GPU"
+      },
+      ...a ? { canvas: this.glCanvas } : {},
+      outputCategoryMask: !0,
+      outputConfidenceMasks: !1,
+      runningMode: "VIDEO"
+    }), a ? (this.drawingUtils = new ws(a), this.useGpuMaskPath = !0) : this.useGpuMaskPath = !1;
+  }
+  async run({
+    sourceCanvas: t,
+    renderWidth: n,
+    renderHeight: r,
+    targetFps: a
+  }) {
+    var o;
+    if (!t)
+      return;
+    this.setTargetFps(a ?? Tn), this.isProcessing = !1, this.rafId !== null && (cancelAnimationFrame(this.rafId), this.rafId = null);
+    const c = this.getQualityScaleFactor();
+    this.sourceCanvas = t, this.processCanvas = document.createElement("canvas"), this.processCanvas.width = t.width * c, this.processCanvas.height = t.height * c, 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, (o = this.segmentationMaskTexture) == null || o.dispose(), this.segmentationMaskTexture = new wt(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 t = this.latestMask.getAsUint8Array();
+    return this.rawCache = {
+      maskData: t,
+      width: this.latestMask.width,
+      height: this.latestMask.height,
+      timestampMs: this.latestMaskTimeMs
+    }, this.rawCache;
+  }
+  getModelNode() {
+    const t = this;
+    return {
+      get backgroundSegmentationMask() {
+        return t.segmentationMaskTexture;
+      },
+      getMaskCanvas: () => t.maskCanvas,
+      getRawSegmentationData: () => t.getRawSegmentationData(),
+      setInputSource: (n) => t.setInputSource(n ?? void 0)
+    };
+  }
+  async getPerformanceData() {
+    return {
+      name: this.constructor.name,
+      processingTime: this.processingTime
+    };
+  }
+}
+const Fn = (e, s, t, n = "feed") => ({
+  width: Math.max(1, Math.round(e)),
+  height: Math.max(1, Math.round(s)),
+  indices: new Uint8Array(Math.max(1, Math.round(e)) * Math.max(1, Math.round(s))),
+  labels: t,
+  space: n,
+  version: 0
+}), Dr = (e) => {
+  e.indices.fill(0);
+}, Lr = (e, s) => e.labels.indexOf(s), In = (e, s, t) => {
+  const { width: n, height: r, indices: a } = e, c = s.length;
+  if (c < 3) return;
+  let o = 1 / 0, d = -1 / 0;
+  for (let y = 0; y < c; y += 1) {
+    const S = s[y].y * r;
+    S < o && (o = S), S > d && (d = S);
+  }
+  const l = Math.max(0, Math.floor(o)), h = Math.min(r - 1, Math.ceil(d)), m = [];
+  for (let y = l; y <= h; y += 1) {
+    const S = y + 0.5;
+    m.length = 0;
+    for (let C = 0; C < c; C += 1) {
+      const E = s[C], _ = s[(C + 1) % c], g = E.y * r, v = _.y * r;
+      if (S < g == S < v) continue;
+      const w = (S - g) / (v - g);
+      m.push((E.x + w * (_.x - E.x)) * n);
+    }
+    m.sort((C, E) => C - E);
+    const M = y * n;
+    for (let C = 0; C + 1 < m.length; C += 2) {
+      const E = Math.max(0, Math.round(m[C])), _ = Math.min(n, Math.round(m[C + 1]));
+      for (let g = E; g < _; g += 1) a[M + g] = t;
+    }
+  }
+}, Or = (e, s, t, n, r = []) => {
+  r.length = 0;
+  for (let a = 0; a < t.length; a += 1) {
+    const c = s[t[a]];
+    if (!c) return;
+    r.push(c);
+  }
+  In(e, r, n);
+}, dt = (e) => e, ht = {
+  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: dt
+  },
+  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: dt
+  }
+}, _n = (e, s, t) => {
+  const n = t.length === e.length ? t : new Uint8Array(e.length);
+  for (let r = 0; r < e.length; r += 1) n[r] = s(e[r]);
+  return n;
+}, Pn = 15, Dn = { low: 0.5, medium: 0.75, high: 1 };
+class Ln extends $ {
+  constructor() {
+    super();
+    u(this, "segmenter", null);
+    u(this, "preset", "hair");
+    u(this, "quality", "medium");
+    u(this, "status", "loading");
+    u(this, "error", null);
+    u(this, "processingTime", null);
+    u(this, "sourceCanvas");
+    u(this, "processCanvas");
+    u(this, "isProcessing", !1);
+    u(this, "mask", Fn(1, 1, ["bg"]));
+    u(this, "node");
+    this.node = {
+      getMask: () => this.mask,
+      getStatus: () => this.status,
+      getError: () => this.error
+    };
+  }
+  async initialize(t) {
+    this.preset = (t == null ? void 0 : t.preset) ?? "hair", this.quality = (t == null ? void 0 : t.quality) ?? "medium";
+    const n = ht[this.preset];
+    this.mask.labels = n.labels, this.status = "loading", this.error = null;
+    try {
+      const r = await Q.forVisionTasks(
+        new URL("/assets/xr/wasm", z.assetStorageEndpoint).toString()
+      ), a = (t == null ? void 0 : t.modelUrl) ?? n.defaultUrl, [c] = await Promise.all([
+        Z(a),
+        J(r)
+      ]);
+      this.segmenter = await pt.createFromOptions(r, {
+        baseOptions: { modelAssetBuffer: c, 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: t, targetFps: n }) {
+    t && (this.setTargetFps(n ?? Pn), this.isProcessing = !1, this.rafId !== null && (cancelAnimationFrame(this.rafId), this.rafId = null), this.sourceCanvas = t, 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: t, sourceCanvas: n, processCanvas: r } = this;
+    if (!t || !n || !r || !this.shouldRunInference()) {
+      this.rafId = requestAnimationFrame(this.process.bind(this));
+      return;
+    }
+    const a = performance.now(), c = Dn[this.quality], o = Math.max(1, Math.round(n.width * c)), d = Math.max(1, Math.round(n.height * c));
+    (r.width !== o || r.height !== d) && (r.width = o, r.height = d);
+    const l = r.getContext("2d");
+    l && l.drawImage(n, 0, 0, o, d);
+    try {
+      const m = t.segmentForVideo(r, performance.now()).categoryMask;
+      if (m) {
+        const y = m.getAsUint8Array();
+        (this.mask.width !== m.width || this.mask.height !== m.height) && (this.mask.width = m.width, this.mask.height = m.height), this.mask.indices = _n(
+          y,
+          ht[this.preset].decode,
+          this.mask.indices
+        ), this.mask.version += 1, this.mask.timestampMs = a, m.close();
+      }
+      this.status === "error" && (this.status = "ready", this.error = null), this.recordInferenceError(null), this.recordDetections(m ? 1 : 0, null);
+    } catch (h) {
+      this.status = "error", this.error = h instanceof Error ? h : new Error(String(h)), 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 t;
+    super.dispose(), this.isProcessing = !1;
+    try {
+      (t = this.segmenter) == null || t.close();
+    } catch {
+    }
+    this.segmenter = null, this.sourceCanvas = void 0, this.processCanvas = void 0;
+  }
+}
+const ut = {
+  [R.BACKGROUND_SEGMENTATION]: Rn,
+  [R.SEMANTIC_SEGMENTATION]: Ln,
+  [R.HAND_TRACKER]: bn,
+  [R.GESTURE_TRACKER]: hn,
+  [R.FACE_TRACKER]: an,
+  [R.BODY_TRACKER]: Js,
+  [R.HOLISTIC_TRACKER]: un
+}, On = async (e) => {
+  const s = document.createElement("video");
+  s.srcObject = e, s.muted = !0, s.playsInline = !0, s.autoplay = !0, await new Promise((n) => {
+    s.onloadedmetadata = () => {
+      s.play(), n();
+    };
+  });
+  const t = s;
+  return await new Promise((n) => {
+    const r = setTimeout(n, 150), a = () => {
+      clearTimeout(r), n();
+    };
+    typeof t.requestVideoFrameCallback == "function" ? t.requestVideoFrameCallback(a) : requestAnimationFrame(() => requestAnimationFrame(() => a()));
+  }), s;
+}, Hn = (e) => {
+  const s = new wt(e);
+  return s.colorSpace = vs, s.format = yt, s.minFilter = ve, s.magFilter = ve, s.generateMipmaps = !1, s.needsUpdate = !0, s;
+}, Nn = (e, s) => {
+  const t = e.videoWidth, n = e.videoHeight;
+  t > 0 && n > 0 && (s.width !== t && (s.width = t), s.height !== n && (s.height = n));
+  const r = s.getContext("2d", {
+    colorSpace: "srgb"
+  });
+  r.save(), r.scale(-1, 1), r.drawImage(e, -s.width, 0, s.width, s.height), r.restore();
+}, Un = (e, s, t = 1) => {
+  const n = s.getContext("2d", {
+    colorSpace: "srgb"
+  }), r = Us({
+    source: { width: e.width, height: e.height },
+    feed: { width: s.width, height: s.height },
+    zoom: t
+  });
+  r && (n.setTransform(1, 0, 0, 1, 0, 0), n.clearRect(0, 0, s.width, s.height), n.drawImage(
+    e,
+    0,
+    0,
+    e.width,
+    e.height,
+    r.offsetX,
+    r.offsetY,
+    r.drawWidth,
+    r.drawHeight
+  ));
+}, Bn = (e, s, t) => {
+  const n = /* @__PURE__ */ new Map(), r = /* @__PURE__ */ new WeakSet();
+  let a = !1;
+  const c = (g, v) => {
+    const w = e.getSnapshot().modelErrors;
+    if (v === null && !w.has(g)) return;
+    const x = new Map(w);
+    v === null ? x.delete(g) : x.set(g, { model: g, error: v, at: performance.now() }), e.set({ modelErrors: x });
+  }, o = (g, v) => {
+    var w;
+    try {
+      (w = v.dispose) == null || w.call(v);
+    } catch (x) {
+      console.warn(`[xr-sdk registry] dispose threw for ${g}`, x);
+    }
+  };
+  return {
+    acquire: async (g, v, w) => {
+      let x = n.get(g);
+      if (x)
+        return x.refs.add(v), x.activeRefs.add(v), x.initPromise;
+      const H = s[g];
+      if (!H)
+        throw new Error(`Invalid model: ${g}`);
+      const T = new H(), U = /* @__PURE__ */ new Set([v]), V = /* @__PURE__ */ new Set([v]);
+      c(g, null);
+      const D = (async () => {
+        await T.initialize(w);
+        const A = n.get(g);
+        if (!A || A.model !== T || A.refs.size === 0)
+          return o(g, T), T;
+        t && await t(g, T);
+        const q = n.get(g);
+        return q && q.refs.size > 0 && (r.add(T), e.setPipeline((K) => K.set(g, T))), T;
+      })();
+      return x = { model: T, refs: U, activeRefs: V, initPromise: D, options: w }, n.set(g, x), D.catch((A) => {
+        n.get(g) === x && (n.delete(g), e.setPipeline((K) => K.delete(g)), c(g, A instanceof Error ? A : new Error(String(A)))), o(g, T);
+      }), D;
+    },
+    release: (g, v) => {
+      const w = n.get(g);
+      w && (w.refs.delete(v), w.activeRefs.delete(v) && w.refs.size > 0 && w.activeRefs.size === 0 && w.model.pause(), !(w.refs.size > 0) && (n.delete(g), o(g, w.model), e.setPipeline((x) => x.delete(g))));
+    },
+    setActive: (g, v, w) => {
+      const x = n.get(g);
+      if (!x || !x.refs.has(v)) return;
+      const H = x.activeRefs.size > 0;
+      w ? x.activeRefs.add(v) : x.activeRefs.delete(v);
+      const T = x.activeRefs.size > 0;
+      H !== T && (T && !a ? x.model.resume() : x.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), o(g, v.model));
+      }
+      e.setPipeline((g) => g.clear());
+    },
+    getState: (g) => {
+      const v = n.get(g);
+      return v ? r.has(v.model) ? "ready" : "initializing" : e.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) : []
+      };
+    }
+  };
+}, zn = {
+  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
+}, Wn = () => {
+  let e = { ...zn, pipeline: /* @__PURE__ */ new Map(), modelErrors: /* @__PURE__ */ new Map() };
+  const s = /* @__PURE__ */ new Set(), t = () => {
+    s.forEach((n) => n());
+  };
+  return {
+    getSnapshot: () => e,
+    set: (n) => {
+      let r = !1;
+      for (const a of Object.keys(n))
+        if (n[a] !== e[a]) {
+          r = !0;
+          break;
+        }
+      r && (e = { ...e, ...n }, t());
+    },
+    setPipeline: (n) => {
+      const r = new Map(e.pipeline);
+      return n(r), e = { ...e, pipeline: r }, t(), r;
+    },
+    subscribe: (n) => (s.add(n), () => {
+      s.delete(n);
+    })
+  };
+}, mt = (e, s) => s ?? e === "user", qn = ({
+  renderHeight: e,
+  renderWidth: s,
+  videoHeight: t,
+  videoWidth: n
+}) => ({
+  height: e || t,
+  width: s || n
+}), Vn = (e, s) => {
+  const t = new zs({ verbose: !0 }), n = Wn();
+  n.set({ cameraZoom: (e == null ? void 0 : e.cameraZoom) ?? 1.2 });
+  let r = s, a = e;
+  const c = (i) => {
+    var p;
+    const f = (p = W.getOptions(i)) == null ? void 0 : p.targetFps;
+    return typeof f == "number" ? f : a == null ? void 0 : a.targetFps;
+  };
+  let o, d, l, h, m, y, S, M, C, E, _, g, v = !1, w = !1, x = !1, H = 0, T, U, V, D = !1, A = 0, q = /* @__PURE__ */ new WeakSet();
+  const K = /* @__PURE__ */ new Set(), pe = (i) => {
+    const f = n.getSnapshot().cameraTexture;
+    f && f.dispose();
+    const p = Hn(i);
+    return n.set({ cameraTexture: p }), p;
+  }, Ce = async (i, f) => {
+    if (q.has(f) || n.getSnapshot().lifecycle !== "running" || !m) return;
+    q.add(f);
+    const p = A;
+    try {
+      await f.run({
+        sourceCanvas: m,
+        renderWidth: n.getSnapshot().renderWidth,
+        renderHeight: n.getSnapshot().renderHeight,
+        getSource: () => n.getSnapshot().sourceKind,
+        targetFps: c(i),
+        analysisScale: a == null ? void 0 : a.analysisScale
+      }), D && (await new Promise((k) => requestAnimationFrame(() => k())), await new Promise((k) => requestAnimationFrame(() => k())), D && A === p && W.suspendAll());
+    } catch (k) {
+      throw q.delete(f), k;
+    }
+  }, W = Bn(n, ut, (i, f) => Ce(i, f));
+  n.subscribe(() => {
+    if (n.getSnapshot().lifecycle !== "running") return;
+    const i = n.getSnapshot().pipeline;
+    for (const [f, p] of i.entries())
+      q.has(p) || Ce(f, p);
+  });
+  const qe = () => {
+    g !== void 0 && (cancelAnimationFrame(g), g = void 0);
+  }, ee = () => {
+    if (qe(), T == null || T(), T = void 0, d) {
+      try {
+        d.pause();
+      } catch {
+      }
+      try {
+        d.srcObject = null;
+      } catch {
+      }
+      d = void 0;
+    }
+    if (l) {
+      try {
+        l.getTracks().forEach((i) => i.stop());
+      } catch {
+      }
+      l = void 0;
+    }
+  }, ke = () => {
+    if (v || !d || !h || !m) return;
+    const i = typeof window < "u" ? window.__xr_debugger_metrics : void 0;
+    if (i != null && i.trackCameraFrame && i.trackCameraFrame(), Me(n.getSnapshot().sourceKind))
+      Nn(d, h);
+    else {
+      const b = h.getContext("2d");
+      if (!b) return;
+      const P = d.videoWidth, L = d.videoHeight;
+      h.width !== P && (h.width = P), h.height !== L && (h.height = L), b.setTransform(1, 0, 0, 1, 0, 0), b.clearRect(0, 0, P, L), b.drawImage(d, 0, 0, P, L);
+    }
+    Un(h, m, (a == null ? void 0 : a.cameraZoom) ?? 1.2);
+    const p = n.getSnapshot();
+    (p.sourceWidth !== d.videoWidth || p.sourceHeight !== d.videoHeight) && n.set({ sourceWidth: d.videoWidth, sourceHeight: d.videoHeight }), H += 1, H % 10 === 0 && n.set({ feedFrames: H });
+    const k = n.getSnapshot().cameraTexture;
+    k && (k.needsUpdate = !0);
+  }, xe = () => {
+    if (!d || !h || !m) return;
+    if (D) {
+      ke();
+      return;
+    }
+    const i = () => {
+      g = requestAnimationFrame(i), ke();
+    };
+    g = requestAnimationFrame(i);
+  }, Dt = async (i, f) => {
+    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 k = i.deviceId ? { deviceId: { exact: i.deviceId } } : { facingMode: { ideal: i.facingMode ?? "user" } }, b = {
+          frameRate: { min: 24, ideal: 30, max: 60 },
+          width: { ideal: p },
+          ...k
+        };
+        let P;
+        try {
+          P = await navigator.mediaDevices.getUserMedia({ video: b });
+        } catch (L) {
+          if (!(L instanceof DOMException && L.name === "OverconstrainedError")) throw L;
+          P = await navigator.mediaDevices.getUserMedia({
+            video: { frameRate: { ideal: 30 }, width: { ideal: p }, ...k }
+          });
+        }
+        return f === A && n.set({ cameraPermission: "granted", cameraPermissionReason: null }), P;
+      } catch (p) {
+        const k = kt(p), b = ct[k], P = await xt(), L = bt(k, P.state);
+        throw f === A && n.set({
+          error: { error: "PermissionError", message: b, reason: k },
+          cameraPermission: L.state,
+          cameraPermissionReason: L.reason
+        }), new O(p instanceof Error ? p.message : "getUserMedia failed");
+      }
+    return i.stream;
+  }, Ve = (i) => {
+    const { lifecycle: f } = n.getSnapshot();
+    f === "idle" || f === "stopped" || v || (ee(), W.suspendAll(), A += 1, o = void 0, n.set({
+      lifecycle: "stopped",
+      ready: !1,
+      error: { error: "PermissionError", message: ct[i], reason: i },
+      cameraPermission: i === "permission-denied" ? "blocked" : "unavailable",
+      cameraPermissionReason: Ct(i)
+    }), t.log("XR session stopped: camera lost.", i));
+  }, Lt = (i) => {
+    var k;
+    T == null || T();
+    const f = ((k = i.getVideoTracks) == null ? void 0 : k.call(i)) ?? [], p = () => {
+      l === i && Ve("camera-lost");
+    };
+    f.forEach((b) => {
+      var P;
+      return (P = b.addEventListener) == null ? void 0 : P.call(b, "ended", p);
+    }), T = () => {
+      f.forEach((b) => {
+        var P;
+        return (P = b.removeEventListener) == null ? void 0 : P.call(b, "ended", p);
+      });
+    };
+  }, Ot = async () => {
+    if (U || typeof navigator > "u") return;
+    const i = navigator.permissions;
+    if (i != null && i.query)
+      try {
+        const f = await i.query({ name: "camera" });
+        if (w) return;
+        U = f, V = () => {
+          f.state === "denied" && (o == null ? void 0 : o.source) === F.WEBCAM && Ve("permission-denied");
+        }, f.addEventListener("change", V);
+      } catch {
+      }
+  }, Ht = () => {
+    var i;
+    U && V && ((i = U.removeEventListener) == null || i.call(U, "change", V)), U = void 0, V = void 0;
+  }, be = async (i) => {
+    var tt, ye, st;
+    const f = A, p = await Dt(i, f);
+    if (f !== A)
+      throw p.getTracks().forEach((re) => re.stop()), new O("Media source superseded by a newer bind");
+    l = p, Lt(p);
+    const k = await On(p);
+    if (f !== A || w)
+      throw p.getTracks().forEach((re) => re.stop()), new O("Media source superseded by a newer bind");
+    d = k, h = new OffscreenCanvas(k.videoWidth, k.videoHeight);
+    const { renderWidth: b, renderHeight: P } = n.getSnapshot(), L = qn({
+      renderWidth: b,
+      renderHeight: P,
+      videoWidth: k.videoWidth,
+      videoHeight: k.videoHeight
+    });
+    m ? (m.width !== L.width || m.height !== L.height) && (m.width = L.width, m.height = L.height, pe(m)) : (m = new OffscreenCanvas(L.width, L.height), pe(m));
+    const et = i.source === F.STREAM ? i.static === !0 : !1;
+    D = et;
+    const ne = (st = (ye = (tt = p.getVideoTracks) == null ? void 0 : tt.call(p)[0]) == null ? void 0 : ye.getSettings) == null ? void 0 : st.call(ye), Fe = ne == null ? void 0 : ne.facingMode, os = Fe === "user" || Fe === "environment" ? Fe : null;
+    if (i.source === F.WEBCAM) {
+      const re = os ?? i.facingMode ?? "user", nt = mt(re, i.mirrored);
+      o = {
+        source: F.WEBCAM,
+        sourceKind: nt ? "webcam" : "rear-camera",
+        facingMode: re,
+        deviceId: i.deviceId,
+        mirrored: nt
+      };
+    } else
+      o = {
+        source: F.STREAM,
+        stream: i.stream,
+        static: et,
+        sourceKind: i.sourceKind ?? "webcam"
+      };
+    n.set({
+      source: i.source,
+      sourceKind: o.sourceKind,
+      cameraFacing: o.source === F.WEBCAM ? o.facingMode : null,
+      cameraDeviceId: o.source === F.WEBCAM ? (ne == null ? void 0 : ne.deviceId) ?? o.deviceId ?? null : null,
+      sourceWidth: k.videoWidth,
+      sourceHeight: k.videoHeight,
+      error: void 0
+    }), i.source === F.WEBCAM && Ot();
+  }, Te = async (i) => {
+    const f = i.sourceKind ?? "webcam";
+    m = i.canvas;
+    const p = pe(m);
+    n.set({
+      cameraTexture: p,
+      source: F.CANVAS,
+      sourceKind: f,
+      cameraFacing: null,
+      cameraDeviceId: null,
+      renderWidth: m.width,
+      renderHeight: m.height,
+      error: void 0
+    }), o = {
+      source: F.CANVAS,
+      canvas: i.canvas,
+      sourceKind: f
+    };
+  }, Nt = (i, f) => {
+    if (!f || i.source !== f.source) return !1;
+    if (i.source === F.STREAM && f.source === F.STREAM)
+      return i.stream === f.stream && (i.sourceKind ?? "webcam") === f.sourceKind;
+    if (i.source === F.WEBCAM && f.source === F.WEBCAM) {
+      const p = i.facingMode ?? "user";
+      return p === f.facingMode && i.deviceId === f.deviceId && mt(p, i.mirrored) === f.mirrored;
+    }
+    return !1;
+  }, Ke = async () => {
+    if (!m) return;
+    const i = A, f = n.getSnapshot().pipeline;
+    for (const [, p] of f.entries())
+      p.resume();
+    await new Promise((p) => requestAnimationFrame(() => p())), await new Promise((p) => requestAnimationFrame(() => p())), D && A === i && W.suspendAll();
+  }, Ut = (i, f) => !f || f.source !== F.CANVAS ? !1 : i.canvas === f.canvas && (i.sourceKind ?? "webcam") === f.sourceKind, Ee = async (i) => {
+    const f = i.source;
+    if (f !== F.WEBCAM && f !== F.STREAM)
+      throw new O(`Invalid media source: ${String(f)}`);
+    if (w) throw new O("session.setMediaSource() called after the provider unmounted");
+    if (Nt(i, o)) {
+      t.log("Media source unchanged, skipping rebind.");
+      return;
+    }
+    A += 1;
+    const { lifecycle: p } = n.getSnapshot();
+    if (p === "idle" || p === "stopped") {
+      await be(i), n.set({ lifecycle: "media-bound" }), t.log("Media source set to:", i.source);
+      return;
+    }
+    if (p === "media-bound") {
+      ee(), await be(i), t.log("Media source rebound to:", i.source);
+      return;
+    }
+    const k = p === "paused";
+    v = !0, await new Promise((b) => requestAnimationFrame(() => b())), ee();
+    try {
+      await be(i);
+    } finally {
+      v = !1;
+    }
+    if (k) {
+      d == null || d.pause(), t.log("Media source swapped (paused) to:", i.source);
+      return;
+    }
+    xe(), D ? await Ke() : W.resumeActive(), t.log("Media source swapped to:", i.source);
+  }, Bt = async (i) => {
+    if (w) throw new O("session.setFrameSource() called after the provider unmounted");
+    if (Ut(i, o)) {
+      t.log("Frame source unchanged, skipping rebind.");
+      return;
+    }
+    A += 1;
+    const { lifecycle: f } = n.getSnapshot();
+    if (f === "idle" || f === "stopped") {
+      await Te(i), n.set({ lifecycle: "media-bound" }), t.log("Frame source set to canvas.");
+      return;
+    }
+    if (f === "media-bound") {
+      ee(), await Te(i), t.log("Frame source rebound to canvas.");
+      return;
+    }
+    v = !0, await new Promise((p) => requestAnimationFrame(() => p())), ee();
+    try {
+      await Te(i);
+    } finally {
+      v = !1;
+    }
+    t.log("Frame source swapped to canvas.");
+  }, Ge = async () => {
+    if (w) throw new O("session.start() called after the provider unmounted");
+    const { lifecycle: i } = n.getSnapshot();
+    if (i === "running") return;
+    if (i === "paused") {
+      await Ae();
+      return;
+    }
+    if (i === "idle")
+      throw new O("session.start() called before setMediaSource — call setMediaSource first");
+    if (!m)
+      throw new O("session.start(): media source not bound");
+    const f = (o == null ? void 0 : o.source) === F.CANVAS;
+    if (!f && (!d || !h))
+      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");
+    f || xe(), W.resumeActive(), n.set({ lifecycle: "running" }), await new Promise((k) => requestAnimationFrame(() => k()));
+    const p = n.getSnapshot().pipeline;
+    for (const [k, b] of p.entries())
+      await Ce(k, b);
+    n.set({ ready: !0 }), t.log("XR session started.");
+  }, Xe = () => {
+    if (n.getSnapshot().lifecycle === "running") {
+      qe(), W.suspendAll();
+      try {
+        d == null || d.pause();
+      } catch {
+      }
+      n.set({ lifecycle: "paused" }), t.log("XR session paused.");
+    }
+  }, Ae = async () => {
+    if (w) throw new O("session.resume() called after the provider unmounted");
+    n.getSnapshot().lifecycle === "paused" && (x = !1, d && d.play().catch(() => {
+    }), (o == null ? void 0 : o.source) !== F.CANVAS && xe(), n.set({ lifecycle: "running" }), D ? await Ke() : W.resumeActive(), t.log("XR session resumed."));
+  }, zt = async (i = {}) => {
+    await Ee({ source: F.WEBCAM, ...i });
+    const { lifecycle: f } = n.getSnapshot();
+    return (f === "media-bound" || f === "stopped") && await Ge(), n.getSnapshot().cameraFacing ?? i.facingMode ?? "user";
+  }, Ye = async () => {
+    const { lifecycle: i } = n.getSnapshot();
+    i === "stopped" || i === "idle" || (x = !1, ee(), W.suspendAll(), o = void 0, n.set({ lifecycle: "stopped", ready: !1 }), t.log("XR session stopped."));
+  }, je = async () => {
+    await Ye(), W.releaseAll(), K.clear();
+    const i = n.getSnapshot().cameraTexture;
+    i && i.dispose(), q = /* @__PURE__ */ new WeakSet(), o = void 0, A += 1, m = void 0, h = void 0, S = void 0, D = !1, Ht(), 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
+    }), t.log("XR session reset.");
+  }, Wt = async () => {
+    w || (w = !0, se == null || se(), se = void 0, te == null || te(), te = void 0, await je(), t.log("XR session disposed."));
+  }, qt = () => {
+    w && (w = !1, $e(), Je(), t.log("XR session re-armed."));
+  }, Vt = () => w, Kt = async (i) => {
+    const f = "legacy:registerXRPipeline", p = [];
+    await Promise.all(
+      i.map(async (k) => {
+        const { model: b } = k;
+        if (!ut[b])
+          throw new O(`Invalid model: ${b}`);
+        K.has(b) || p.push(b);
+        const P = "options" in k ? k.options : void 0;
+        await W.acquire(b, f, P);
+      })
+    ), p.length > 0 && (p.forEach((k) => K.add(k)), t.log("XR pipeline registered."));
+  }, Gt = (i) => {
+    const f = W.get(i);
+    if (!f)
+      throw new O(`Model ${i} is not registered in the pipeline`);
+    return f.getModelNode();
+  }, Qe = async (i, f) => {
+    i <= 0 || f <= 0 || (n.set({ renderWidth: i, renderHeight: f }), m && (m.width !== i || m.height !== f) && (m.width = i, m.height = f, pe(m), D && ke()), t.log(`Source canvas set. Render size: ${i}x${f}`));
+  }, Xt = async (i) => {
+    var b;
+    y = i;
+    const f = (b = i.getBoundingClientRect) == null ? void 0 : b.call(i), p = f && f.width > 0 ? Math.round(f.width) : i.clientWidth, k = f && f.height > 0 ? Math.round(f.height) : i.clientHeight;
+    await Qe(p, k);
+  }, Yt = (i) => {
+    S = i;
+  }, Re = () => y && M && C && E ? y : S, jt = (i) => {
+    M = i.renderer, C = i.scene, E = i.camera, _ = i.renderFrame;
+  }, Ze = () => {
+    if (!M || !C || !E)
+      throw new O(
+        "XR frame render requested before the R3F state was bound — make sure <XRScene> is mounted"
+      );
+    _ ? _() : M.render(C, E);
+  }, Qt = () => {
+    const i = y;
+    if (i && Re() === i)
+      return Ze(), i.toDataURL("image/png");
+    const f = Re();
+    if (f) return f.toDataURL("image/png");
+    throw new O(
+      "session.captureFrame() called before an XRScene or XRMediaSurface capture target was bound"
+    );
+  }, Zt = (i = 30) => {
+    const f = Re();
+    if (!(f != null && f.captureStream))
+      throw new O(
+        "session.captureStream() called before an XRScene or XRMediaSurface capture target was bound"
+      );
+    return f.captureStream(i);
+  }, Jt = () => d, $t = () => m ?? null, es = (i) => {
+    if (a = i, n.set({ cameraZoom: (i == null ? void 0 : i.cameraZoom) ?? 1.2 }), n.getSnapshot().lifecycle !== "running" || !m) return;
+    const f = n.getSnapshot().pipeline;
+    for (const [p, k] of f.entries())
+      k.run({
+        sourceCanvas: m,
+        renderWidth: n.getSnapshot().renderWidth,
+        renderHeight: n.getSnapshot().renderHeight,
+        getSource: () => n.getSnapshot().sourceKind,
+        targetFps: c(p),
+        analysisScale: a == null ? void 0 : a.analysisScale
+      });
+  }, ts = () => a, ss = async () => {
+    if (!o || o.source !== F.WEBCAM) return;
+    const { facingMode: i, deviceId: f, mirrored: p } = o;
+    o = void 0, await Ee({ source: F.WEBCAM, facingMode: i, deviceId: f, mirrored: p });
+  }, ns = (i) => {
+    n.set({ quality: i });
+  }, rs = (i) => {
+    n.set({ qualityConfig: i });
+  }, as = (i) => {
+    r = i;
+  }, is = () => {
+    var b;
+    if (typeof window > "u") return { type: "portrait", angle: 0 };
+    const i = (b = window.screen) == null ? void 0 : b.orientation, f = (i == null ? void 0 : i.angle) ?? 0, p = f === 90 || f === 180 || f === 270 ? f : 0;
+    return { type: i != null && i.type ? i.type.startsWith("landscape") ? "landscape" : "portrait" : window.innerWidth > window.innerHeight ? "landscape" : "portrait", angle: p };
+  }, ce = () => {
+    const i = is(), f = n.getSnapshot().orientation, p = f.type !== i.type || f.angle !== i.angle ? { orientation: i } : {};
+    d && d.videoWidth > 0 && (p.sourceWidth = d.videoWidth, p.sourceHeight = d.videoHeight), Object.keys(p).length && n.set(p);
+  };
+  let te;
+  const Je = () => {
+    var f, p, k;
+    if (te || typeof window > "u") return;
+    const i = (f = window.screen) == null ? void 0 : f.orientation;
+    (p = i == null ? void 0 : i.addEventListener) == null || p.call(i, "change", ce), (k = window.addEventListener) == null || k.call(window, "resize", ce), te = () => {
+      var b, P;
+      (b = i == null ? void 0 : i.removeEventListener) == null || b.call(i, "change", ce), (P = window.removeEventListener) == null || P.call(window, "resize", ce);
+    }, ce();
+  };
+  let se;
+  const $e = () => {
+    if (se || typeof document > "u" || typeof document.addEventListener != "function") return;
+    const i = () => {
+      if (!w) {
+        if (document.hidden) {
+          r != null && r.pauseWhenHidden && n.getSnapshot().lifecycle === "running" && (Xe(), x = !0);
+          return;
+        }
+        if (x && n.getSnapshot().lifecycle === "paused") {
+          Ae();
+          return;
+        }
+        n.getSnapshot().lifecycle === "running" && (d != null && d.paused) && d.play().catch(() => {
+        });
+      }
+    };
+    document.addEventListener("visibilitychange", i), se = () => document.removeEventListener("visibilitychange", i);
+  };
+  return $e(), Je(), {
+    store: n,
+    registry: W,
+    setMediaSource: Ee,
+    start: Ge,
+    stop: Ye,
+    reset: je,
+    pause: Xe,
+    resume: Ae,
+    switchCamera: zt,
+    dispose: Wt,
+    rearm: qt,
+    isDisposed: Vt,
+    setFrameSource: Bt,
+    registerXRPipeline: Kt,
+    getModelNode: Gt,
+    captureFrame: Qt,
+    captureStream: Zt,
+    getInputFrame: $t,
+    _setRenderTarget: Xt,
+    _setCaptureTarget: Yt,
+    _setRenderSize: Qe,
+    _setR3FState: jt,
+    _renderFrame: Ze,
+    _getVideoElement: Jt,
+    _setPerf: es,
+    _setLifecycle: as,
+    _rebindMedia: ss,
+    _setQuality: ns,
+    _setQualityConfig: rs,
+    _getPerf: ts
+  };
+}, Kn = (e, s) => {
+  const t = oe(e), n = oe(s), r = ge(
+    () => Vn(t.current, n.current),
+    []
+  ), a = JSON.stringify(s ?? {});
+  he(() => {
+    r._setLifecycle(s);
+  }, [r, a]), he(() => (r.rearm(), () => void r.dispose()), [r]);
+  const c = JSON.stringify(e ?? {});
+  return he(() => {
+    r._setPerf(e);
+  }, [r, c]), r;
+}, He = /* @__PURE__ */ new Map(), Gn = () => ({
+  register: (e, s) => {
+    s ? He.set(e, s) : He.delete(e);
+  },
+  resolve: (e) => e ? He.get(e) ?? null : null
+}), At = Gn(), Rt = gt(null), Xn = ({ children: e }) => {
+  const s = oe(/* @__PURE__ */ new Map()), t = at((a, c) => {
+    c ? s.current.set(a, c) : s.current.delete(a);
+  }, []), n = at(
+    (a) => a ? s.current.get(a) ?? null : null,
+    []
+  ), r = ge(() => ({ register: t, resolve: n }), [t, n]);
+  return hs(Rt.Provider, { value: r }, e);
+}, Ft = () => Be(Rt) ?? At, Hr = () => Ft().register, Nr = () => Ft().resolve;
+At.register;
+const Yn = {
+  [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"
+}, ft = Object.values(R), jn = (e, s) => {
+  var n;
+  const t = (n = e.registry.getOptions(s)) == null ? void 0 : n.targetFps;
+  return typeof t == "number" ? t : null;
+}, Ue = (e, s, t, n = performance.now()) => {
+  const r = e.store.getSnapshot(), a = t ? n - t.sampledAt : 0, c = t && a > 0 ? Math.max(0, (r.feedFrames - t.feedFrames) * 1e3 / a) : 0, o = r.lifecycle === "running", d = s.map((h) => {
+    var E;
+    const m = e.registry.getState(h), y = e.store.getSnapshot().pipeline.get(h), S = ((E = r.modelErrors.get(h)) == null ? void 0 : E.error) ?? null, M = (y == null ? void 0 : y.getDiagnostics()) ?? {
+      inferenceMs: null,
+      inferenceFps: 0,
+      inferences: 0,
+      skippedFrames: 0,
+      detections: null,
+      confidence: null,
+      status: S ? "error" : "ready",
+      error: S,
+      paused: !1,
+      disposed: !1
+    };
+    let C;
+    return m === "error" || M.status === "error" ? C = "error" : m === "idle" ? C = "unavailable" : m === "initializing" ? C = "loading" : M.paused || !o ? C = "paused" : C = "ready", {
+      ...M,
+      error: M.error ?? S,
+      model: h,
+      label: Yn[h] ?? h,
+      state: C,
+      targetFps: jn(e, h),
+      owners: e.registry.getOwners(h)
+    };
+  }), l = r.quality;
+  return {
+    quality: l ? {
+      tier: l.decision.tier.name,
+      index: l.index,
+      locked: l.locked,
+      reason: l.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: c,
+      feedFrames: r.feedFrames
+    },
+    models: d,
+    inferenceMsTotal: d.reduce(
+      (h, m) => h + (m.state === "ready" ? m.inferenceMs ?? 0 : 0),
+      0
+    ),
+    sampledAt: n
+  };
+}, Ur = (e = {}) => {
+  const { intervalMs: s = 250, enabled: t = !0 } = e, { session: n } = Pt(), r = (e.models ?? ft).join("|"), a = ge(
+    () => e.models && e.models.length ? e.models : ft,
+    // modelsKey captures the list by value.
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [r]
+  ), c = oe(null), [o, d] = us(
+    () => Ue(n, a, null)
+  );
+  return he(() => {
+    if (!t) return;
+    const l = () => {
+      const m = Ue(n, a, c.current);
+      c.current = { feedFrames: m.session.feedFrames, sampledAt: m.sampledAt }, d(m);
+    };
+    l();
+    const h = window.setInterval(l, Math.max(50, s));
+    return () => window.clearInterval(h);
+  }, [n, a, s, t]), o;
+}, Qn = [
+  { 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 }
+], j = {
+  maxFrameMs: 1e3 / 24,
+  maxInferenceMs: 24,
+  maxMemoryMb: null,
+  sampleMs: 1e3,
+  downgradeAfter: 2,
+  upgradeAfter: 6,
+  upgradeHeadroom: 0.75,
+  cooldownMs: 4e3
+}, It = {
+  frameMs: null,
+  fps: null,
+  inferenceMs: null,
+  feedFps: null,
+  memoryMb: null,
+  deviceMemoryGb: null,
+  hardwareConcurrency: null,
+  thermal: "unknown"
+}, fe = (e, s, t) => Math.min(t, Math.max(s, e)), N = (e, s) => typeof e == "number" && Number.isFinite(e) ? e : s, Zn = (e, s) => ({
+  name: typeof e.name == "string" && e.name ? e.name : `tier-${s}`,
+  ...N(e.targetFps, NaN) > 0 ? { targetFps: N(e.targetFps, 0) } : {},
+  ...N(e.renderScale, NaN) > 0 ? { renderScale: fe(N(e.renderScale, 1), 0.25, 1) } : {},
+  ...N(e.analysisScale, NaN) > 0 ? { analysisScale: fe(N(e.analysisScale, 1), 0.25, 1) } : {},
+  ...N(e.camRes, NaN) > 0 ? { camRes: Math.round(N(e.camRes, 0)) } : {},
+  ...e.rebindCamera ? { rebindCamera: !0 } : {}
+}), Jn = (e = {}) => ({
+  maxFrameMs: Math.max(1, N(e.maxFrameMs, j.maxFrameMs)),
+  maxInferenceMs: Math.max(
+    0,
+    N(e.maxInferenceMs, j.maxInferenceMs)
+  ),
+  maxMemoryMb: e.maxMemoryMb === null || e.maxMemoryMb === void 0 ? null : Math.max(1, N(e.maxMemoryMb, 0)) || null,
+  sampleMs: Math.max(100, N(e.sampleMs, j.sampleMs)),
+  downgradeAfter: Math.max(
+    1,
+    Math.round(N(e.downgradeAfter, j.downgradeAfter))
+  ),
+  upgradeAfter: Math.max(
+    1,
+    Math.round(N(e.upgradeAfter, j.upgradeAfter))
+  ),
+  upgradeHeadroom: fe(
+    N(e.upgradeHeadroom, j.upgradeHeadroom),
+    0.1,
+    1
+  ),
+  cooldownMs: Math.max(0, N(e.cooldownMs, j.cooldownMs))
+}), Y = (e, s, t) => {
+  if (typeof s == "number" && Number.isInteger(s) && s >= 0 && s < e.length)
+    return s;
+  if (typeof s == "string") {
+    const n = e.findIndex((r) => r.name === s);
+    if (n >= 0) return n;
+  }
+  return t;
+}, $n = (e = {}) => {
+  const s = e.tiers && e.tiers.length ? e.tiers.map((r, a) => Zn(r, a)) : Qn, t = Y(s, e.maxTier, 0), n = Math.max(t, Y(s, e.minTier, s.length - 1));
+  return {
+    tiers: s,
+    budget: Jn(e.budget),
+    ...e.initialTier !== void 0 ? { initialTier: e.initialTier } : {},
+    minTier: n,
+    maxTier: t,
+    adaptive: e.adaptive !== !1,
+    historySize: Math.max(1, Math.round(N(e.historySize, 20)))
+  };
+}, er = (e, s) => {
+  const t = Y(e.tiers, e.maxTier, 0), n = Y(e.tiers, e.minTier, e.tiers.length - 1);
+  if (e.initialTier !== void 0)
+    return fe(Y(e.tiers, e.initialTier, t), t, n);
+  const r = s.deviceMemoryGb !== null && s.deviceMemoryGb <= 4 || s.hardwareConcurrency !== null && s.hardwareConcurrency <= 4;
+  return fe(r ? t + 1 : t, t, n);
+}, _t = (e, s = It, t = 0) => {
+  const n = er(e, s), r = { index: n, tier: e.tiers[n], reason: "init", at: t };
+  return {
+    index: n,
+    locked: !1,
+    badStreak: 0,
+    goodStreak: 0,
+    lastChangeAt: t,
+    decision: r,
+    history: [r],
+    signals: s
+  };
+}, Se = (e, s, t, n, r, a = e.signals) => {
+  const c = { index: t, tier: s.tiers[t], reason: n, at: r };
+  return {
+    ...e,
+    index: t,
+    badStreak: 0,
+    goodStreak: 0,
+    lastChangeAt: r,
+    decision: c,
+    history: [c, ...e.history].slice(0, s.historySize),
+    signals: a
+  };
+}, tr = (e, s) => e.thermal === "critical" ? "thermal" : s.maxMemoryMb !== null && e.memoryMb !== null && e.memoryMb > s.maxMemoryMb ? "memory" : e.inferenceMs !== null && e.inferenceMs > s.maxInferenceMs ? "inference" : e.frameMs !== null && e.frameMs > s.maxFrameMs ? "frame-time" : null, sr = (e, s, t, n) => {
+  const { budget: r } = t, a = Y(t.tiers, t.maxTier, 0), c = Y(t.tiers, t.minTier, t.tiers.length - 1);
+  if (e.locked || !t.adaptive) return { ...e, signals: s };
+  const o = tr(s, r), d = o === null && s.frameMs !== null && s.frameMs <= r.maxFrameMs * r.upgradeHeadroom && (s.inferenceMs === null || s.inferenceMs <= r.maxInferenceMs * r.upgradeHeadroom), l = o ? e.badStreak + 1 : 0, h = d ? e.goodStreak + 1 : 0, m = n - e.lastChangeAt >= r.cooldownMs;
+  if (o && l >= r.downgradeAfter && m) {
+    if (e.index < c)
+      return Se(e, t, e.index + 1, o, n, s);
+    const y = o === "frame-time" ? "suspected" : s.thermal;
+    return { ...e, badStreak: l, goodStreak: h, signals: { ...s, thermal: y } };
+  }
+  return d && h >= r.upgradeAfter && m && e.index > a ? Se(e, t, e.index - 1, "recovered", n, s) : { ...e, badStreak: l, goodStreak: h, signals: s };
+}, Br = (e, s, t, n) => {
+  const r = Y(s.tiers, t, e.index);
+  return r === e.index ? e : Se(e, s, r, "manual", n);
+}, zr = (e, s, t, n) => t === e.locked ? e : { ...Se(e, s, e.index, t ? "locked" : "manual", n), locked: t }, nr = (e, s) => e.decision.tier === s ? null : e.decision.tier, Wr = (e, s, t) => {
+  const n = _t(e, s, t);
+  return {
+    ...n,
+    decision: { ...n.decision, reason: "reset" },
+    history: [{ ...n.decision, reason: "reset" }]
+  };
+}, rr = Object.values(R), ar = () => {
+  if (typeof navigator > "u") return { deviceMemoryGb: null, hardwareConcurrency: null };
+  const e = navigator;
+  return {
+    deviceMemoryGb: typeof e.deviceMemory == "number" ? e.deviceMemory : null,
+    hardwareConcurrency: typeof e.hardwareConcurrency == "number" ? e.hardwareConcurrency : null
+  };
+}, ir = () => {
+  const e = performance.memory;
+  return e ? e.usedJSHeapSize / 1048576 : null;
+}, or = ({ config: e, thermal: s, onDecision: t }) => {
+  const { session: n } = Pt(), r = JSON.stringify(e ?? {}), a = ge(() => $n(e), [r]), c = oe(s ?? "unknown");
+  c.current = s ?? "unknown";
+  const o = oe(t);
+  return o.current = t, he(() => {
+    const d = ar();
+    let l = _t(
+      a,
+      { ...It, ...d },
+      performance.now()
+    );
+    const h = n.store.getSnapshot().quality;
+    h && h.index < a.tiers.length && (l = {
+      ...h,
+      decision: { ...h.decision, tier: a.tiers[h.index] }
+    }), n._setQualityConfig(a), n._setQuality(l);
+    let m = n._getPerf(), y = null;
+    const S = async (w, x) => {
+      const H = {
+        ...m,
+        ...w.targetFps !== void 0 ? { targetFps: w.targetFps } : {},
+        ...w.analysisScale !== void 0 ? { analysisScale: w.analysisScale } : {},
+        ...w.camRes !== void 0 && w.rebindCamera ? { camRes: w.camRes } : {}
+      };
+      n._setPerf(H), w.rebindCamera && w.camRes !== void 0 && w.camRes !== (x == null ? void 0 : x.camRes) && await n._rebindMedia().catch(() => {
+      });
+    };
+    y = l.decision.tier, S(l.decision.tier, null);
+    let M = 0, C = performance.now(), E = 0;
+    const _ = () => {
+      M += 1, E = requestAnimationFrame(_);
+    };
+    E = requestAnimationFrame(_);
+    let g = null;
+    const v = window.setInterval(() => {
+      var q;
+      if (typeof document < "u" && document.hidden) {
+        M = 0, C = performance.now();
+        return;
+      }
+      const w = performance.now(), x = w - C, H = Ue(n, rr, g, w);
+      g = { feedFrames: H.session.feedFrames, sampledAt: w };
+      const T = n.store.getSnapshot().lifecycle === "running", U = {
+        frameMs: M > 0 && x > 0 && T ? x / M : null,
+        fps: M > 0 && x > 0 ? M * 1e3 / x : null,
+        inferenceMs: T ? H.inferenceMsTotal : null,
+        feedFps: H.session.feedFps,
+        memoryMb: ir(),
+        ...d,
+        thermal: c.current
+      };
+      M = 0, C = w;
+      const V = n.store.getSnapshot().quality ?? l, D = sr(V, U, a, w);
+      l = D, n._setQuality(D);
+      const A = nr(D, y);
+      if (A) {
+        const K = y;
+        y = A, S(A, K), (q = o.current) == null || q.call(o, D);
+      }
+    }, a.budget.sampleMs);
+    return () => {
+      cancelAnimationFrame(E), window.clearInterval(v);
+      const w = (y == null ? void 0 : y.rebindCamera) && y.camRes !== void 0;
+      n._setPerf(m), w && (m == null ? void 0 : m.camRes) !== (y == null ? void 0 : y.camRes) && n._rebindMedia().catch(() => {
+      }), m = void 0, n._setQualityConfig(null);
+    };
+  }, [n, a]), null;
+}, We = gt(void 0), Pt = () => {
+  const e = Be(We);
+  if (!e)
+    throw new O(
+      "XR context can only be used inside XRProvider, did you forget to wrap your app in <XRProvider>?"
+    );
+  return e;
+}, qr = () => Be(We) ?? null, Vr = ({ children: e, perf: s, lifecycle: t, quality: n }) => {
+  const r = Kn(s, t), a = ge(() => ({ session: r }), [r]);
+  return /* @__PURE__ */ ds(We.Provider, { value: a, children: [
+    n !== !1 && /* @__PURE__ */ rt(or, { config: n || void 0 }),
+    /* @__PURE__ */ rt(Xn, { children: e })
+  ] });
+};
+export {
+  As as $,
+  qr as A,
+  I as B,
+  z as C,
+  Nr as D,
+  It as E,
+  Ss as F,
+  ze as G,
+  wn as H,
+  xt as I,
+  wr as J,
+  vr as K,
+  Sr as L,
+  Mr as M,
+  Vr as N,
+  Bs as O,
+  kr as P,
+  xr as Q,
+  br as R,
+  ht as S,
+  Tr as T,
+  Cr as U,
+  Ar as V,
+  Rr as W,
+  R as X,
+  mn as Y,
+  yn as Z,
+  St as _,
+  Pr as a,
+  Mt as a0,
+  pr as a1,
+  j as a2,
+  Qn as a3,
+  or as a4,
+  Ne as a5,
+  vn as a6,
+  vt as a7,
+  Ms as a8,
+  Cs as a9,
+  ks as aa,
+  Ue as ab,
+  kt as ac,
+  bt as ad,
+  Ur as ae,
+  Yn as af,
+  Ps as ag,
+  _t as ah,
+  tr as ai,
+  ar as aj,
+  er as ak,
+  Jn as al,
+  Zn as am,
+  sr as an,
+  nr as ao,
+  In as ap,
+  Lr as aq,
+  Mn as ar,
+  Sn as as,
+  Cn as at,
+  Hr as au,
+  Fr as av,
+  Xs as aw,
+  tn as ax,
+  sn as ay,
+  J as az,
+  fr as b,
+  Us as c,
+  gr as d,
+  Br as e,
+  Ir as f,
+  Wr as g,
+  Gs as h,
+  Me as i,
+  Ks as j,
+  Ws as k,
+  zr as l,
+  yr as m,
+  ue as n,
+  De as o,
+  _r as p,
+  fn as q,
+  $n as r,
+  Ct as s,
+  Er as t,
+  Pt as u,
+  Ns as v,
+  Dr as w,
+  Or as x,
+  Fn as y,
+  F as z
+};