@vincentt-xr/sdk 2.0.0-alpha.0 → 2.0.0-alpha.10

package/dist/index-CKRN-xJp.js

@@ -0,0 +1,3740 @@
+var As = Object.defineProperty;
+var Is = (e, s, t) => s in e ? As(e, s, { enumerable: !0, configurable: !0, writable: !0, value: t }) : e[s] = t;
+var u = (e, s, t) => Is(e, typeof s != "symbol" ? s + "" : s, t);
+import { jsxs as Fs, jsx as yt } from "react/jsx-runtime";
+import { useRef as he, useMemo as xe, useEffect as ye, useContext as Je, useCallback as wt, createElement as Ps, createContext as _t, useState as _s } from "react";
+import { FilesetResolver as $, PoseLandmarker as Ds, FaceLandmarker as Os, GestureRecognizer as Ls, HolisticLandmarker as Ns, HandLandmarker as Bs, ImageSegmenter as Dt, DrawingUtils as Hs } from "@mediapipe/tasks-vision";
+import * as z from "three";
+import { Vector2 as Us, Raycaster as zs, Ray as Ws, Vector3 as qs, RGBAFormat as Ot, LinearFilter as Re, CanvasTexture as Lt, SRGBColorSpace as Vs } from "three";
+const W = {
+  // 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",
+  // Debug-ui sample media (the preview presets: clips and stills). Overridable
+  // at app start — the playground points it at a local folder while new clips
+  // are reviewed before they are published to the CDN.
+  debugMediaBaseUrl: "https://cdn.vincentt.studio/assets/sdk/debug-ui/v1",
+  loggerPrefix: "[vincentt-xr]:",
+  sessionCheckInterval: 3e4
+};
+var P = /* @__PURE__ */ ((e) => (e.WEBCAM = "webcam", e.STREAM = "stream", e.CANVAS = "canvas", e))(P || {}), F = /* @__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))(F || {});
+const He = (e) => Array.from({ length: e }, () => ({ x: 0, y: 0, z: 0 }));
+class Ks {
+  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: i, maxVelocityGapMs: r = 250 } = this.options, o = [], a = Math.max(s.length, this.slots.length);
+    for (let d = 0; d < a; d += 1) {
+      const l = s[d], h = this.slots[d] ?? null;
+      if (l && l.length > 0) {
+        const M = h && h.points.length === l.length ? h : null, x = M ?? {
+          points: He(l.length),
+          velocity: He(l.length),
+          lastSeen: t,
+          output: He(l.length)
+        }, b = (t - x.lastSeen) / 1e3, T = M !== null && b > 0 && b * 1e3 <= r;
+        for (let R = 0; R < l.length; R += 1) {
+          const y = l[R], g = x.points[R], p = x.velocity[R], v = y.z ?? 0;
+          T ? (p.x = 0.5 * p.x + 0.5 * ((y.x - g.x) / b), p.y = 0.5 * p.y + 0.5 * ((y.y - g.y) / b), p.z = 0.5 * p.z + 0.5 * ((v - g.z) / b)) : (p.x = 0, p.y = 0, p.z = 0), g.x = y.x, g.y = y.y, g.z = v;
+        }
+        x.lastSeen = t, this.slots[d] = x, o.push(l);
+        continue;
+      }
+      if (!h) continue;
+      const m = t - h.lastSeen;
+      if (m > n) {
+        this.slots[d] = null;
+        continue;
+      }
+      const w = Math.max(0, Math.min(m, i)) / 1e3;
+      for (let M = 0; M < h.points.length; M += 1)
+        h.output[M].x = h.points[M].x + h.velocity[M].x * w, h.output[M].y = h.points[M].y + h.velocity[M].y * w, h.output[M].z = h.points[M].z + h.velocity[M].z * w;
+      o.push(h.output);
+    }
+    for (; this.slots.length > 0 && this.slots[this.slots.length - 1] === null; ) this.slots.pop();
+    return o;
+  }
+  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), Gs = (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), Nt = "https://storage.googleapis.com/mediapipe-models/holistic_landmarker/holistic_landmarker/float16/latest/holistic_landmarker.task", Xs = 250, Ys = 0, js = 768, je = (e) => ({
+  hands: (e == null ? void 0 : e.hands) ?? "both",
+  analysisMaxDimension: (e == null ? void 0 : e.analysisMaxDimension) ?? js,
+  holdMs: (e == null ? void 0 : e.holdMs) ?? Xs,
+  predictMs: (e == null ? void 0 : e.predictMs) ?? Ys
+}), Qs = () => ({
+  version: 0,
+  timestampMs: 0,
+  face: null,
+  leftHand: null,
+  rightHand: null,
+  pose: null
+}), vt = [
+  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
+], xt = (e, s) => {
+  if (e.length !== vt.length) return e;
+  s.length = e.length;
+  for (let t = 0; t < e.length; t += 1) s[t] = e[vt[t]];
+  return s;
+};
+class ke {
+  constructor(s, t) {
+    u(this, "memory");
+    u(this, "holdMs");
+    u(this, "lastLiveMs", -1 / 0);
+    u(this, "lastConfidence", 0);
+    this.holdMs = s, this.memory = new Ks({ 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 i = s !== void 0 && s.length > 0, r = this.memory.update(i ? [s] : [], n)[0];
+    if (!r) return;
+    if (i)
+      return this.lastLiveMs = n, this.lastConfidence = t, { points: r, held: !1, confidence: t };
+    const o = n - this.lastLiveMs, a = this.holdMs > 0 ? Math.max(0, 1 - o / this.holdMs) : 0;
+    return { points: r, held: !0, confidence: this.lastConfidence * a };
+  }
+}
+const ce = (e, s, t) => {
+  for (e.length > s && (e.length = s); e.length < s; ) e.push(t());
+  return e;
+}, Ue = (e, s) => {
+  e.x = s.x, e.y = s.y, e.z = s.z;
+}, Js = (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 Zs {
+  constructor(s) {
+    u(this, "options", je());
+    u(this, "faceMemory", new ke(this.options.holdMs, this.options.predictMs));
+    u(this, "leftHandMemory", new ke(this.options.holdMs, this.options.predictMs));
+    u(this, "rightHandMemory", new ke(this.options.holdMs, this.options.predictMs));
+    u(this, "poseMemory", new ke(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 = je({ ...this.options, ...s });
+    const { holdMs: t, predictMs: n } = this.options;
+    for (const i of this.memories()) i.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, i = !1) {
+    var l, h, m, w;
+    n.face = this.updateFace(s, t);
+    const r = {
+      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]
+    }, o = {
+      landmarks: (m = s == null ? void 0 : s.rightHandLandmarks) == null ? void 0 : m[0],
+      world: (w = s == null ? void 0 : s.rightHandWorldLandmarks) == null ? void 0 : w[0]
+    }, a = i ? o : r, d = i ? r : o;
+    return n.leftHand = this.updateHand("left", a.landmarks, a.world, t), n.rightHand = this.updateHand("right", d.landmarks, d.world, t), n.pose = this.updatePose(s, t, i), n.timestampMs = t, n.version += 1, n;
+  }
+  updateFace(s, t) {
+    var a, d, l, h;
+    const n = (a = s == null ? void 0 : s.faceLandmarks) == null ? void 0 : a[0], i = this.faceMemory.bridge(n, 1, t);
+    if (!i) return null;
+    const { face: r } = this, o = !i.held && n;
+    ce(r.landmarks, i.points.length, () => ({
+      x: 0,
+      y: 0,
+      z: 0,
+      visibility: 0
+    }));
+    for (let m = 0; m < i.points.length; m += 1) {
+      const w = r.landmarks[m];
+      Ue(w, i.points[m]), w.visibility = o ? ((d = n[m]) == null ? void 0 : d.visibility) ?? 0 : 0;
+    }
+    if (o) {
+      const m = (h = (l = s == null ? void 0 : s.faceBlendshapes) == null ? void 0 : l[0]) == null ? void 0 : h.categories;
+      if (m)
+        for (const w of m) r.blendshapes[w.categoryName] = w.score;
+    }
+    return r.confidence = i.confidence, r.held = i.held, r;
+  }
+  updateHand(s, t, n, i) {
+    const r = s === "left" ? this.leftHandMemory : this.rightHandMemory, { hands: o } = this.options;
+    if (o === "none" || o !== "both" && o !== s)
+      return r.reset(), null;
+    const a = r.bridge(t, 1, i);
+    if (!a) return null;
+    const d = s === "left" ? this.leftHand : this.rightHand;
+    ce(d.landmarks, a.points.length, () => ({ x: 0, y: 0, z: 0 }));
+    for (let l = 0; l < a.points.length; l += 1)
+      ue(a.points[l], d.landmarks[l]);
+    if (!a.held && n) {
+      ce(d.worldLandmarks, n.length, () => ({ x: 0, y: 0, z: 0 }));
+      for (let l = 0; l < n.length; l += 1) Ue(d.worldLandmarks[l], n[l]);
+    }
+    return d.confidence = a.confidence, d.held = a.held, d;
+  }
+  updatePose(s, t, n) {
+    var m, w, M;
+    const i = (m = s == null ? void 0 : s.poseLandmarks) == null ? void 0 : m[0], r = i && n ? xt(i, this.poseScratch) : i, o = this.poseMemory.bridge(r, r ? Js(r) : 0, t);
+    if (!o) return null;
+    const { pose: a } = this, d = !o.held && r;
+    ce(a.landmarks, o.points.length, () => ({ x: 0, y: 0, z: 0 })), ce(a.visibility, o.points.length, () => 0);
+    for (let x = 0; x < o.points.length; x += 1)
+      ue(o.points[x], a.landmarks[x]), d && (a.visibility[x] = ((w = r[x]) == null ? void 0 : w.visibility) ?? 0);
+    const l = (M = s == null ? void 0 : s.poseWorldLandmarks) == null ? void 0 : M[0], h = l && n ? xt(l, this.poseWorldScratch) : l;
+    if (d && h) {
+      ce(a.worldLandmarks, h.length, () => ({ x: 0, y: 0, z: 0 }));
+      for (let x = 0; x < h.length; x += 1) Ue(a.worldLandmarks[x], h[x]);
+    }
+    return a.confidence = o.confidence, a.held = o.held, a;
+  }
+}
+const Bt = {
+  "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."
+}, $s = {
+  "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
+}, _ = (e, s = Bt[e]) => ({ code: e, message: s, recoverable: $s[e] }), en = {
+  [F.FACE_TRACKER]: "/assets/xr/models/face_tracking.task",
+  [F.HAND_TRACKER]: "/assets/xr/models/hand_tracking.task",
+  [F.GESTURE_TRACKER]: "/assets/xr/models/gesture_tracking.task",
+  [F.BODY_TRACKER]: "/assets/xr/models/body_tracking.task",
+  [F.BACKGROUND_SEGMENTATION]: "/assets/xr/models/segmentation.tflite",
+  [F.SEMANTIC_SEGMENTATION]: "/assets/xr/models/selfie_multiclass_256x256.tflite",
+  [F.HOLISTIC_TRACKER]: Nt
+}, Ht = (e) => {
+  const s = en[e];
+  return s ? /^https?:/.test(s) ? s : new URL(s, W.assetStorageEndpoint).toString() : null;
+}, tn = Object.values(F), sn = () => {
+  var t, n, i;
+  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) ? (r) => navigator.xr.isSessionSupported(r).catch(() => !1) : void 0,
+    relSupportsAr: s ? ((i = (n = document.createElement("a").relList) == null ? void 0 : n.supports) == null ? void 0 : i.call(n, "ar")) === !0 : void 0,
+    userAgent: typeof navigator < "u" ? navigator.userAgent : void 0
+  };
+}, nn = (e) => !!e && /Android/.test(e) && /(Chrome|SamsungBrowser)\//.test(e) && !/Firefox|OPR\//.test(e), rn = async (e) => {
+  let s = !1;
+  if (e.xrSessionSupported)
+    try {
+      s = await e.xrSessionSupported("immersive-ar");
+    } catch {
+      s = !1;
+    }
+  const t = nn(e.userAgent), n = e.relSupportsAr === !0, i = s || t || n;
+  return {
+    webxr: s,
+    sceneViewer: t,
+    quickLook: n,
+    any: i,
+    reason: i ? null : _("placement-unsupported")
+  };
+}, an = (e) => {
+  switch (e) {
+    case "granted":
+      return "supported";
+    case "denied":
+      return "permission-denied";
+    case "prompt":
+      return "permission-prompt";
+    default:
+      return "unknown";
+  }
+}, on = async (e, s) => {
+  var a, d, l;
+  const t = e.isSecureContext ?? !0, n = (a = e.navigator) == null ? void 0 : a.mediaDevices;
+  if (!t)
+    return {
+      status: "unsupported",
+      reason: _("camera-insecure-context"),
+      deviceCount: null,
+      secureContext: t
+    };
+  if (!n || typeof n.getUserMedia != "function")
+    return {
+      status: "unsupported",
+      reason: _("camera-unsupported"),
+      deviceCount: null,
+      secureContext: t
+    };
+  let i = "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" });
+      i = an(h.state);
+    } catch {
+      i = "unknown";
+    }
+  let r = null, o = !1;
+  if (typeof n.enumerateDevices == "function")
+    try {
+      const h = await n.enumerateDevices();
+      r = h.filter((m) => m.kind === "videoinput").length, o = h.some((m) => !!m.label);
+    } catch {
+      r = null;
+    }
+  return i === "permission-denied" ? {
+    status: i,
+    reason: _("camera-permission-denied"),
+    deviceCount: r,
+    secureContext: t
+  } : r === 0 && (i === "supported" || o) ? {
+    status: "unsupported",
+    reason: _("no-camera"),
+    deviceCount: r,
+    secureContext: t
+  } : { status: i, reason: null, deviceCount: r, secureContext: t };
+}, cn = (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;
+}, ln = (e) => {
+  var o;
+  const s = cn(e), t = e.offscreenCanvas ?? !1, n = e.wasm ?? !1, i = !!((o = e.navigator) != null && o.gpu);
+  let r = null;
+  return s === 0 ? r = _("webgl-unavailable") : t ? n || (r = _("wasm-unavailable")) : r = _("offscreen-canvas-unavailable"), {
+    status: r ? "unsupported" : "supported",
+    reason: r,
+    webglVersion: s,
+    webgpu: i,
+    offscreenCanvas: t,
+    wasm: n
+  };
+}, dn = async (e, s, t) => {
+  var o, a;
+  const n = Ht(e);
+  if (!n || !s.fetch)
+    return { model: e, status: "unknown", reason: null, url: n, bytes: null };
+  const i = typeof AbortController < "u" ? new AbortController() : void 0, r = setTimeout(() => i == null ? void 0 : i.abort(), t);
+  try {
+    const d = await s.fetch(n, { method: "HEAD", signal: i == null ? void 0 : i.signal });
+    if (!d.ok)
+      return {
+        model: e,
+        status: "unsupported",
+        reason: _(
+          "model-unreachable",
+          `${Bt["model-unreachable"]} (${d.status})`
+        ),
+        url: n,
+        bytes: null
+      };
+    const l = Number(((a = (o = d.headers) == null ? void 0 : o.get) == null ? void 0 : a.call(o, "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: _("model-unreachable"),
+      url: n,
+      bytes: null
+    };
+  } finally {
+    clearTimeout(r);
+  }
+}, ir = async (e = {}, s = sn()) => {
+  const t = e.timeoutMs ?? 4e3, n = new Set(e.models ?? []), [i, r, o] = await Promise.all([
+    on(s, e.queryPermission ?? !0),
+    Promise.all(
+      tn.map(
+        async (l) => n.has(l) ? dn(l, s, t) : {
+          model: l,
+          status: "unknown",
+          reason: null,
+          url: Ht(l),
+          bytes: null
+        }
+      )
+    ),
+    rn(s)
+  ]), a = ln(s), d = Object.fromEntries(r.map((l) => [l.model, l]));
+  return {
+    camera: i,
+    rendering: a,
+    placement: o,
+    models: d,
+    canRunTracking: a.status === "supported" && i.status !== "unsupported",
+    checkedAt: s.now ? s.now() : Date.now()
+  };
+}, Ut = (e) => {
+  switch (e) {
+    case "permission-denied":
+      return _("camera-permission-denied");
+    case "camera-in-use":
+      return _("camera-in-use");
+    case "no-camera":
+      return _("no-camera");
+    case "camera-lost":
+      return _("camera-lost");
+    case "unsupported":
+      return _("camera-unsupported");
+    default:
+      return _("unknown");
+  }
+}, rr = (e, s) => {
+  const { camera: t, rendering: n } = e, i = e.models[s], r = t.status === "permission-prompt" || t.status === "unknown";
+  return n.reason ? { supported: !1, reason: n.reason, needsPermission: r } : t.reason ? { supported: !1, reason: t.reason, needsPermission: r } : i != null && i.reason ? { supported: !1, reason: i.reason, needsPermission: r } : { supported: !0, reason: null, needsPermission: r };
+}, ar = (e) => {
+  const s = e instanceof Error ? e.message : String(e ?? ""), t = s.toLowerCase();
+  return t.includes("integrity") || t.includes("sha-384") || t.includes("sha384") ? _("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") ? _("model-unreachable", s) : t.includes("webgl") || t.includes("gpu") ? _("webgl-unavailable", s) : s ? _("model-init-failed", s) : _("unknown");
+}, zt = (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";
+  }
+}, St = {
+  "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
+}), Wt = 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 };
+  }
+}, qt = (e, s) => e === "permission-denied" ? {
+  state: s === "blocked" ? "blocked" : "denied",
+  reason: _("camera-permission-denied")
+} : { state: "unavailable", reason: Ut(e) }, or = async (e = {}, s = Ze()) => {
+  var n;
+  if (s.isSecureContext === !1)
+    return {
+      state: "unavailable",
+      reason: _("camera-insecure-context"),
+      stream: null
+    };
+  const t = (n = s.mediaDevices) == null ? void 0 : n.getUserMedia;
+  if (typeof t != "function")
+    return {
+      state: "unavailable",
+      reason: _("camera-unsupported"),
+      stream: null
+    };
+  try {
+    const i = await t.call(
+      s.mediaDevices,
+      e.constraints ?? { video: { facingMode: "user" } }
+    );
+    return e.keepStream ? { state: "granted", reason: null, stream: i } : (i.getTracks().forEach((r) => r.stop()), { state: "granted", reason: null, stream: null });
+  } catch (i) {
+    const r = zt(i), o = await Wt(s);
+    return { ...qt(r, o.state), stream: null };
+  }
+}, cr = async (e, s = Ze()) => {
+  var t, n;
+  if (!((t = s.permissions) != null && t.query)) return () => {
+  };
+  try {
+    const i = await s.permissions.query({ name: "camera" }), r = () => {
+      i.state === "granted" ? e({ state: "granted", prompt: !1 }) : i.state === "denied" ? e({ state: "blocked", prompt: !1 }) : e({ state: "unknown", prompt: i.state === "prompt" });
+    };
+    return (n = i.addEventListener) == null || n.call(i, "change", r), () => {
+      var o;
+      return (o = i.removeEventListener) == null ? void 0 : o.call(i, "change", r);
+    };
+  } catch {
+    return () => {
+    };
+  }
+}, lr = (e) => e === "unknown" || e === "denied" || e === "granted", dr = {
+  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."
+}, hn = (e, s, t = "cover", n = 1) => {
+  if (e.width <= 0 || e.height <= 0 || s.width <= 0 || s.height <= 0)
+    return null;
+  const i = Number.isFinite(n) && n > 0 ? n : 1, r = s.width / e.width, o = s.height / e.height, a = t === "contain" ? o <= r : o >= r, d = (a ? o : r) * i, l = a ? e.width * o * i : s.width * i, h = a ? s.height * i : e.height * r * i;
+  return {
+    scale: d,
+    drawWidth: l,
+    drawHeight: h,
+    offsetX: (s.width - l) / 2,
+    offsetY: (s.height - h) / 2
+  };
+}, Se = (e) => e === "webcam" || e === void 0, un = ({
+  source: e,
+  feed: s,
+  zoom: t = 1,
+  mirrored: n = !1
+}) => {
+  const i = hn(e, s, "cover", t);
+  return i ? { ...i, source: e, feed: s, zoom: Number.isFinite(t) && t > 0 ? t : 1, mirrored: n } : null;
+}, hr = (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;
+}, mn = (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;
+}, ur = (e, s) => {
+  const t = mn(e, s);
+  return t.x >= 0 && t.x <= s.source.width && t.y >= 0 && t.y <= s.source.height;
+}, mr = (e, s = { x: 0, y: 0 }) => (s.x = 1 - e.x, s.y = e.y, e.z !== void 0 && (s.z = e.z), s), fr = (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;
+  }
+}, gr = (e, s) => s === 90 || s === 270 ? { width: e.height, height: e.width } : { width: e.width, height: e.height };
+class N extends Error {
+  constructor(s) {
+    super(s), this.name = "VincenttXRError";
+  }
+}
+class fn {
+  constructor(s) {
+    u(this, "options");
+    const t = {
+      verbose: !1,
+      prefix: W.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 Vt = [
+  "nose",
+  "leftEyeInner",
+  "leftEye",
+  "leftEyeOuter",
+  "rightEyeInner",
+  "rightEye",
+  "rightEyeOuter",
+  "leftEar",
+  "rightEar",
+  "mouthLeft",
+  "mouthRight",
+  "leftShoulder",
+  "rightShoulder",
+  "leftElbow",
+  "rightElbow",
+  "leftWrist",
+  "rightWrist",
+  "leftPinky",
+  "rightPinky",
+  "leftIndex",
+  "rightIndex",
+  "leftThumb",
+  "rightThumb",
+  "leftHip",
+  "rightHip",
+  "leftKnee",
+  "rightKnee",
+  "leftAnkle",
+  "rightAnkle",
+  "leftHeel",
+  "rightHeel",
+  "leftFootIndex",
+  "rightFootIndex"
+], pe = Object.fromEntries(
+  Vt.map((e, s) => [e, s])
+), gn = (e) => e === "mouthLeft" ? "mouthRight" : e === "mouthRight" ? "mouthLeft" : e.startsWith("left") ? `right${e.slice(4)}` : e.startsWith("right") ? `left${e.slice(5)}` : e, pn = Object.freeze(
+  Vt.map((e) => pe[gn(e)])
+), yn = (e, s = { x: 0, y: 0, z: 0 }) => (s.x = e.x * 100, s.y = -e.y * 100, s.z = -e.z * 100, s), wn = (e, s, t) => {
+  if (!s) return { ...e, timestampMs: t };
+  const n = (i) => i.map((r, o) => i[pn[o] ?? o] ?? i[o]);
+  return {
+    world: n(e.world),
+    image: n(e.image),
+    visibility: n(e.visibility),
+    timestampMs: t
+  };
+}, vn = Object.freeze({
+  holdMs: 250,
+  maxJump: 1,
+  duplicate: 0.1,
+  confirm: 3,
+  confirmMs: 100
+}), xn = 1, Sn = 1.2, Mn = 200, ze = [pe.leftShoulder, pe.rightShoulder, pe.leftHip, pe.rightHip], bn = (e, s) => {
+  const t = ze.map((w) => e.image[w]);
+  if (t.some((w) => !w)) return null;
+  const n = (w) => ({ x: w.x * s, y: w.y }), [i, r, o, a] = t.map(n), d = { x: (i.x + r.x) / 2, y: (i.y + r.y) / 2 }, l = { x: (o.x + a.x) / 2, y: (o.y + a.y) / 2 }, h = Math.max(
+    Math.hypot(d.x - l.x, d.y - l.y),
+    Math.hypot(i.x - r.x, i.y - r.y)
+  );
+  if (!(h > 1e-6)) return null;
+  const m = ze.reduce((w, M) => w + (e.visibility[M] ?? 0), 0) / ze.length;
+  return {
+    pose: e,
+    center: { x: (d.x + l.x) / 2, y: (d.y + l.y) / 2 },
+    size: h,
+    visibility: m
+  };
+};
+class kn {
+  constructor(s = {}) {
+    u(this, "settings");
+    u(this, "tracks", []);
+    u(this, "nextId", 1);
+    this.settings = { ...vn, ...s };
+  }
+  /**
+   * One detection's bodies (any order) at `nowMs`; `aspect` is the analysed
+   * frame's width / height. Returns every tracked body, by id.
+   */
+  update(s, t, n = 1) {
+    const { holdMs: i, maxJump: r, duplicate: o, confirm: a, confirmMs: d } = this.settings, l = this.dedupe(
+      s.map((g) => bn(g, n)).filter((g) => !!g),
+      o
+    ), h = l.map(
+      (g) => this.tracks.map((p) => {
+        const v = Math.min(Math.max(t - p.lastSeenMs, 0), Mn), A = p.center.x + p.velocity.x * v, E = p.center.y + p.velocity.y * v, B = Math.max(p.size, g.size), K = Math.hypot(g.center.x - A, g.center.y - E) / B;
+        return K > r ? 1 / 0 : K + xn * Math.abs(Math.log(g.size / p.size));
+      })
+    );
+    let m = l.map(() => -1), w = 1 / 0;
+    const M = [], x = /* @__PURE__ */ new Set(), b = (g, p) => {
+      if (!(p >= w)) {
+        if (g === l.length) {
+          m = [...M], w = p;
+          return;
+        }
+        for (let v = 0; v < this.tracks.length; v += 1) {
+          const A = h[g][v];
+          x.has(v) || A === 1 / 0 || (x.add(v), M[g] = v, b(g + 1, p + A), x.delete(v));
+        }
+        M[g] = -1, b(g + 1, p + Sn);
+      }
+    };
+    b(0, 0);
+    const T = /* @__PURE__ */ new Set(), y = !this.tracks.some((g) => g.id !== null) ? l.reduce(
+      (g, p, v) => m[v] < 0 && (!g || p.visibility > g.visibility) ? p : g,
+      null
+    ) : null;
+    l.forEach((g, p) => {
+      const v = m[p] >= 0 ? this.tracks[m[p]] : null;
+      if (!v) {
+        const E = {
+          id: null,
+          hits: 1,
+          firstSeenMs: t,
+          pose: g.pose,
+          center: g.center,
+          size: g.size,
+          velocity: { x: 0, y: 0 },
+          lastSeenMs: t
+        };
+        (g === y || a <= 1 && d <= 0) && this.confirm(E), this.tracks.push(E), T.add(E);
+        return;
+      }
+      v.hits += 1, v.id === null && v.hits >= a && t - v.firstSeenMs >= d && this.confirm(v);
+      const A = t - v.lastSeenMs;
+      A > 0 && (v.velocity = {
+        x: (v.velocity.x + (g.center.x - v.center.x) / A) / 2,
+        y: (v.velocity.y + (g.center.y - v.center.y) / A) / 2
+      }), v.pose = g.pose, v.center = g.center, v.size = g.size, v.lastSeenMs = t, T.add(v);
+    }), this.tracks = this.tracks.filter(
+      (g) => T.has(g) || g.id !== null && t - g.lastSeenMs <= i
+    );
+    for (const g of this.tracks) T.has(g) || (g.hits = 0);
+    return this.tracks.filter((g) => g.id !== null).map((g) => ({ id: g.id, pose: g.pose, held: !T.has(g) })).sort((g, p) => g.id - p.id);
+  }
+  confirm(s) {
+    s.id = this.nextId, this.nextId += 1;
+  }
+  /** Forget every body; ids keep counting up. */
+  reset() {
+    this.tracks = [];
+  }
+  /** One person detected twice (overlapping tracking regions): keep the more visible. */
+  dedupe(s, t) {
+    const n = [], i = [...s].sort((r, o) => o.visibility - r.visibility);
+    for (const r of i)
+      n.some(
+        (a) => Math.hypot(a.center.x - r.center.x, a.center.y - r.center.y) / Math.max(a.size, r.size) < t && Math.abs(Math.log(a.size / r.size)) < 0.1
+      ) || n.push(r);
+    return s.filter((r) => n.includes(r));
+  }
+}
+const Mt = (e, s) => {
+  let t = 1;
+  for (const n of e) Number.isFinite(n) && (t = Math.max(t, Math.round(n)));
+  return Math.min(t, s);
+}, V = {
+  width: 720,
+  height: 1280
+}, J = 32, Cn = 0.5, Ce = {
+  enabled: !0,
+  position: { x: 0, y: 0 },
+  size: { width: 680, height: 1230 },
+  pivot: [0.5, 0.5],
+  rotation: 0,
+  scale2D: { x: 1, y: 1 },
+  referencePixelsPerUnit: J,
+  renderOrder: 999,
+  overlay: !0,
+  visible: !0,
+  showTransformGuides: !1
+}, Tn = Math.PI / 180, bt = (e, s) => s <= 0 ? e : Math.round(e / s) * s, pr = ({
+  transform: e,
+  parentSize: s,
+  root: t = V,
+  snapIncrement: n = Cn
+}) => {
+  const r = Math.min(s.width / t.width, s.height / t.height) * (J / e.referencePixelsPerUnit), o = e.size.width * e.scale2D.x * r, a = e.size.height * e.scale2D.y * r, d = bt(e.position.x, n) * r, l = bt(e.position.y, n) * r, h = (e.pivot[0] - 0.5) * o, m = (e.pivot[1] - 0.5) * a;
+  return {
+    center: [d - h, l - m, 0],
+    size: [o, a, 1],
+    rotation: [0, 0, e.rotation * Tn],
+    pivotOffset: [h / Math.max(o, 1e-6), m / Math.max(a, 1e-6), 0],
+    aspect: o > 0 && a > 0 ? Math.abs(o / a) : 1
+  };
+}, yr = (e) => ({
+  ...Ce,
+  ...e,
+  position: { ...Ce.position, ...e == null ? void 0 : e.position },
+  size: { ...Ce.size, ...e == null ? void 0 : e.size },
+  scale2D: { ...Ce.scale2D, ...e == null ? void 0 : e.scale2D }
+}), U = (e, s) => {
+  if (!Number.isFinite(e) || e <= 0) throw new RangeError(`${s} must be positive`);
+  return e;
+}, En = (e, s) => {
+  const t = U(s.width, "root.width"), n = U(s.height, "root.height");
+  return !Number.isFinite(e.width) || !Number.isFinite(e.height) || e.width <= 0 || e.height <= 0 ? 0 : Math.min(e.width / t, e.height / n);
+}, $e = (e, s, t, n) => s.width <= 0 || s.height <= 0 ? Object.assign(n, { x: 0, y: 0 }) : (U(t.width, "root.width"), U(t.height, "root.height"), n.x = (e.x / s.width - 0.5) * t.width, n.y = (0.5 - e.y / s.height) * t.height, n), et = (e, s, t, n) => s.width <= 0 || s.height <= 0 ? Object.assign(n, { x: 0, y: 0 }) : (U(t.width, "root.width"), U(t.height, "root.height"), n.x = (e.x / t.width + 0.5) * s.width, n.y = (0.5 - e.y / t.height) * s.height, n), Kt = ({
+  parentSize: e,
+  referencePixelsPerUnit: s = J,
+  root: t = V
+}) => En(e, t) * (J / U(s, "referencePixelsPerUnit")), wr = (e, s) => e * Kt(s), vr = (e, s) => {
+  const t = Kt(s);
+  return t === 0 ? 0 : e / t;
+}, xr = ({
+  point: e,
+  parentSize: s,
+  referencePixelsPerUnit: t = J,
+  root: n = V,
+  target: i = { x: 0, y: 0 }
+}) => {
+  if (s.width <= 0 || s.height <= 0) return Object.assign(i, { x: 0, y: 0 });
+  const r = J / U(t, "referencePixelsPerUnit");
+  return i.x = e.x * (s.width / U(n.width, "root.width")) * r, i.y = e.y * (s.height / U(n.height, "root.height")) * r, i;
+}, Sr = ({
+  point: e,
+  parentSize: s,
+  referencePixelsPerUnit: t = J,
+  root: n = V,
+  target: i = { x: 0, y: 0 }
+}) => {
+  if (s.width <= 0 || s.height <= 0) return Object.assign(i, { x: 0, y: 0 });
+  const r = J / U(t, "referencePixelsPerUnit");
+  return i.x = e.x / (s.width / U(n.width, "root.width") * r), i.y = e.y / (s.height / U(n.height, "root.height") * r), i;
+}, Mr = ({
+  point: e,
+  rect: s,
+  root: t = V,
+  target: n = { x: 0, y: 0 }
+}) => $e({ x: e.x - s.left, y: e.y - s.top }, s, t, n), br = ({
+  point: e,
+  rect: s,
+  root: t = V,
+  target: n = { x: 0, y: 0 }
+}) => (et(e, s, t, n), n.x += s.left, n.y += s.top, n), Gt = ({
+  point: e,
+  root: s = V,
+  target: t = { x: 0, y: 0 },
+  viewportSize: n
+}) => $e(
+  { x: e.x * n.width, y: e.y * n.height },
+  n,
+  s,
+  t
+), Rn = ({
+  point: e,
+  root: s = V,
+  target: t = { x: 0, y: 0 },
+  viewportSize: n
+}) => n.width <= 0 || n.height <= 0 ? Object.assign(t, { x: 0, y: 0 }) : (et(e, n, s, t), t.x /= n.width, t.y /= n.height, t), kr = ({
+  point: e,
+  root: s = V,
+  target: t = { x: 0, y: 0 },
+  viewportSize: n
+}) => Gt({
+  point: { x: (e.x + 1) / 2, y: (1 - e.y) / 2 },
+  viewportSize: n,
+  root: s,
+  target: t
+}), Cr = ({
+  layout: e,
+  mirrored: s = !1,
+  point: t,
+  root: n = V,
+  target: i = { x: 0, y: 0 }
+}) => {
+  if (e.scale <= 0) return Object.assign(i, { x: 0, y: 0 });
+  const r = e.offsetX + t.x * e.scale;
+  return $e(
+    {
+      x: s ? e.destination.width - r : r,
+      y: e.offsetY + t.y * e.scale
+    },
+    e.destination,
+    n,
+    i
+  );
+}, Tr = ({
+  layout: e,
+  mirrored: s = !1,
+  point: t,
+  root: n = V,
+  target: i = { x: 0, y: 0 }
+}) => {
+  if (e.scale <= 0) return Object.assign(i, { x: 0, y: 0 });
+  et(t, e.destination, n, i);
+  const r = s ? e.destination.width - i.x : i.x;
+  return i.x = (r - e.offsetX) / e.scale, i.y = (i.y - e.offsetY) / e.scale, i;
+}, Te = new qs(), kt = new Us(), Ct = new zs(), Er = ({
+  camera: e,
+  point: s,
+  root: t = V,
+  target: n = { x: 0, y: 0, depth: 0 },
+  viewportSize: i
+}) => (U(t.width, "root.width"), U(t.height, "root.height"), Te.set(s.x, s.y, s.z).project(e), n.x = Te.x * t.width / 2, n.y = Te.y * t.height / 2, n.depth = Te.z, n), Rr = ({
+  camera: e,
+  point: s,
+  root: t = V,
+  target: n = new Ws(),
+  viewportSize: i
+}) => (U(t.width, "root.width"), U(t.height, "root.height"), kt.set(s.x * 2 / t.width, s.y * 2 / t.height), Ct.setFromCamera(kt, e), n.copy(Ct.ray)), Ar = (e, s) => ue({ x: e.x, y: e.y, z: e.z ?? 0 }, s), An = (e, s = { x: 0, y: 0 }) => {
+  const t = Gs(e);
+  return s.x = t.x, s.y = t.y, s.z = t.z, s;
+}, Ir = (e, s, t = { x: 0, y: 0 }) => (t.x = e.x * s.width, t.y = e.y * s.height, t), Fr = (e, s, t = { x: 0, y: 0 }) => s.width <= 0 || s.height <= 0 ? Object.assign(t, { x: 0, y: 0 }) : (t.x = e.x / s.width, t.y = e.y / s.height, t), Pr = (e, s, t = {}) => Gt({
+  point: e,
+  viewportSize: s,
+  root: t.root,
+  target: t.target
+}), _r = (e, s, t = {}) => {
+  const n = t.target ?? { x: 0, y: 0 };
+  return Rn({ point: e, viewportSize: s, root: t.root, target: n }), n;
+}, In = { selection: "index", index: 0 }, Tt = Object.freeze({
+  face: { max: 10, default: 1, option: "numFaces" },
+  hand: { max: 2, default: 2, option: null },
+  gesture: { max: 1, default: 1, option: null },
+  body: { max: 2, default: 1, option: "numBodies" },
+  holistic: { max: 1, default: 1, option: null }
+}), Fn = { center: null }, de = (e, s) => Math.hypot(e.x - s.x, e.y - s.y), Ee = (e) => ({
+  center: { ...e.center },
+  ...e.label === void 0 ? {} : { label: e.label },
+  ...e.id === void 0 ? {} : { id: e.id }
+}), Et = (e, s, t) => {
+  if (!e.length) return null;
+  switch (s) {
+    case "largest":
+      return e.reduce((n, i) => i.size > n.size ? i : n);
+    case "nearest-center":
+      return e.reduce(
+        (n, i) => de(i.center, { x: 0.5, y: 0.5 }) < de(n.center, { x: 0.5, y: 0.5 }) ? i : n
+      );
+    case "leftmost":
+      return e.reduce((n, i) => i.center.x < n.center.x ? i : n);
+    case "rightmost":
+      return e.reduce((n, i) => i.center.x > n.center.x ? i : n);
+    default:
+      return e.find((n) => n.index === t) ?? null;
+  }
+}, Dr = (e, s = In, t = Fn) => {
+  const n = s.index ?? 0;
+  if (s.selection !== "sticky") {
+    const a = Et(e, s.selection, n);
+    return {
+      index: (a == null ? void 0 : a.index) ?? null,
+      reason: a ? s.selection : "none",
+      memory: a ? Ee(a) : t
+    };
+  }
+  const i = t.id === void 0 ? void 0 : e.find((a) => a.id === t.id);
+  if (i) return { index: i.index, reason: "sticky", memory: Ee(i) };
+  const r = s.stickyRadius ?? 0.2;
+  if (t.center) {
+    const a = t.center, d = e.filter((m) => de(m.center, a) <= r).sort((m, w) => de(m.center, a) - de(w.center, a)), h = (t.label ? d.find((m) => m.label === t.label) : void 0) ?? d[0];
+    if (h)
+      return { index: h.index, reason: "sticky", memory: Ee(h) };
+  }
+  const o = Et(e, s.fallback ?? "largest", n);
+  return {
+    index: (o == null ? void 0 : o.index) ?? null,
+    reason: o ? "sticky-fallback" : "none",
+    // Keep the old memory on a miss so a brief dropout does not forget the subject.
+    memory: o ? Ee(o) : t
+  };
+}, Or = (e) => e.map((s, t) => {
+  let n = 1 / 0, i = -1 / 0, r = 1 / 0, o = -1 / 0;
+  for (const d of s)
+    d.x < n && (n = d.x), d.x > i && (i = d.x), d.y < r && (r = d.y), d.y > o && (o = d.y);
+  const a = s.length > 0 && Number.isFinite(n);
+  return {
+    index: t,
+    center: a ? { x: (n + i) / 2, y: (r + o) / 2 } : { x: 0.5, y: 0.5 },
+    size: a ? i - n : 0
+  };
+}), Pn = (e) => e.map((s, t) => {
+  const n = (s.coordinates ?? []).map((l) => An(l));
+  let i = 1 / 0, r = -1 / 0, o = 1 / 0, a = -1 / 0;
+  for (const l of n)
+    l.x < i && (i = l.x), l.x > r && (r = l.x), l.y < o && (o = l.y), l.y > a && (a = l.y);
+  const d = n.length > 0;
+  return {
+    index: t,
+    center: d ? { x: (i + r) / 2, y: (o + a) / 2 } : { x: 0.5, y: 0.5 },
+    size: d ? Math.max(r - i, a - o) : 0,
+    ...s.label ? { label: s.label } : {}
+  };
+}), Lr = (e) => Pn(e.map((s) => ({ coordinates: s.pose.image }))).map((s, t) => ({
+  ...s,
+  id: e[t].id
+})), Nr = (e, s, t = 0.35) => {
+  const n = [];
+  for (const o of e)
+    for (const a of s) {
+      const d = de(o.center, a.center);
+      d <= t && n.push({ primaryIndex: o.index, secondaryIndex: a.index, distance: d });
+    }
+  n.sort((o, a) => o.distance - a.distance);
+  const i = /* @__PURE__ */ new Set(), r = /* @__PURE__ */ new Set();
+  return n.filter((o) => i.has(o.primaryIndex) || r.has(o.secondaryIndex) ? !1 : (i.add(o.primaryIndex), r.add(o.secondaryIndex), !0));
+}, Rt = new z.Vector3(), We = new z.Vector3(), Xt = (e, s, t, n, i) => {
+  Rt.set(e, s, 0).unproject(t), We.copy(Rt).sub(t.position).normalize();
+  const r = (n - t.position.z) / We.z;
+  return i.copy(t.position).addScaledVector(We, r);
+}, _n = (e, s, t = new z.Vector3(), n = 0) => Xt((e.x - 0.5) * 2, (0.5 - e.y) * 2, s, n, t), Br = (e, s, t = new z.Vector3(), n = 0) => Xt(e.x, e.y, s, n, t), j = new z.Vector3(), Hr = (e, s, t = { x: 0, y: 0, z: 0 }) => (j.set(e.x, e.y, e.z).project(s), t.x = j.x / 2 + 0.5, t.y = 0.5 - j.y / 2, t.z = j.z, t), Ur = (e, s, t = { x: 0, y: 0, z: 0 }) => (j.set(e.x, e.y, e.z).project(s), t.x = j.x, t.y = j.y, t.z = j.z, t), qe = (e, s, t) => _n(e, s, t, 0), Dn = (e, s, t = 0.2) => t * s + (1 - t) * e;
+class we {
+  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, i = Math.min(
+      1,
+      this.maxDimension * this.scale / Math.max(t, n)
+    );
+    if (i >= 1) return s;
+    const r = Math.max(1, Math.round(t * i)), o = Math.max(1, Math.round(n * i));
+    (!this.canvas || this.canvas.width !== r || this.canvas.height !== o) && (this.canvas = new OffscreenCanvas(r, o));
+    const a = this.canvas.getContext("2d");
+    return a ? (a.setTransform(1, 0, 0, 1, 0, 0), a.clearRect(0, 0, r, o), a.drawImage(s, 0, 0, r, o), this.canvas) : s;
+  }
+  dispose() {
+    this.canvas = void 0;
+  }
+}
+const On = {
+  "/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",
+  // SDK-hosted rig models (lib/assets/sdkModels.ts): the CDN copies must be
+  // byte-identical to example/src/assets/models/{hand-v1,glove-v1,ybot}.glb.
+  // Upload pending: the default URLs fail closed until then.
+  "/assets/xr/3d-models/hand-v1.glb": "sha384-noiRM38+PSoOZVgKaRLPf1001gHN38vMDPkSX2mL/Wgtj9o7TP/L05rHs6ubsGIK",
+  "/assets/xr/3d-models/glove-v1.glb": "sha384-dZkRdB4URmKS2RBaDb4A7E95pLt4KKLlkxKsqA6L5N8elSbfiyyBoi7S9GcSVbDJ",
+  "/assets/xr/3d-models/ybot-v1.glb": "sha384-pJY/JqDrnL8qPVtTC52G1GVsbBwBkEN5Z2TX3mm921l/iLsFTJDHbEMWcLd+icZ9",
+  // 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",
+  // Fingernail segmenter behind the `nails` preset (assets-src/nail-segmenter):
+  // the CDN copy must be byte-identical to example/src/assets/models.
+  "/assets/xr/models/nail_segmenter_v1.tflite": "sha384-sxkDgbQcK1Q/bxxzAHGvmSG00wm11UlrlH9dS242lo9QGBqBCEr4zj6sZE3mND43",
+  // 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 Ln(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(), i = Hn(e);
+  if (!i) {
+    if (Nn(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 r = await Un(n);
+  if (r !== i)
+    throw new Error(
+      `[xr-sdk integrity] SRI mismatch for ${e}: expected ${i}, got ${r}`
+    );
+  return n;
+}
+function Nn(e) {
+  try {
+    return new URL(e).origin === new URL(W.assetStorageEndpoint).origin;
+  } catch {
+    return !1;
+  }
+}
+async function ee(e) {
+  const s = await Ln(e);
+  return new Uint8Array(s);
+}
+const le = /* @__PURE__ */ new Map();
+function Bn(e) {
+  let s = le.get(e);
+  if (!s) {
+    const i = { bytes: ee(e), holders: 0 };
+    i.bytes.catch(() => {
+      le.get(e) === i && le.delete(e);
+    }), le.set(e, i), s = i;
+  }
+  const t = s;
+  t.holders += 1;
+  let n = !1;
+  return {
+    bytes: t.bytes,
+    release: () => {
+      n || (n = !0, t.holders -= 1, t.holders <= 0 && le.get(e) === t && le.delete(e));
+    }
+  };
+}
+function Hn(e) {
+  try {
+    const s = new URL(e);
+    return On[s.pathname];
+  } catch {
+    return;
+  }
+}
+async function Un(e) {
+  const s = await crypto.subtle.digest("SHA-384", e), t = new Uint8Array(s);
+  let n = "";
+  for (let i = 0; i < t.byteLength; i++)
+    n += String.fromCharCode(t[i]);
+  return `sha384-${btoa(n)}`;
+}
+const Ve = /* @__PURE__ */ new Map();
+function te(e) {
+  const s = e.wasmBinaryPath;
+  let t = Ve.get(s);
+  return t || (t = zn(s).catch(() => {
+    Ve.delete(s);
+  }), Ve.set(s, t)), t;
+}
+async function zn(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 se {
+  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 i = t - this.statWindowStart;
+    return i >= 1e3 && (this.statFps = this.statWindowCount * 1e3 / i, 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 Wn = 768, Ke = (e) => e > 1 ? "IMAGE" : "VIDEO";
+class qn extends se {
+  constructor() {
+    super();
+    u(this, "landmarker", null);
+    u(this, "processingTime", null);
+    u(this, "coordinates");
+    u(this, "visibility");
+    /** Per body, sided as the person's own left / right (see `anatomicalBodyPose`). */
+    u(this, "poses", []);
+    /** The same bodies with a stable id each (`BodyIdentity`), by id. */
+    u(this, "bodies", []);
+    u(this, "identity", new kn());
+    /** How many bodies the landmarker looks for now, and what each consumer asked for. */
+    u(this, "numPoses", 1);
+    u(this, "bodyRequests", /* @__PURE__ */ new Map());
+    /** While `setOptions` rebuilds the landmarker, inference waits. */
+    u(this, "reconfiguring", !1);
+    u(this, "getSource");
+    u(this, "sourceCanvas");
+    u(this, "downscaler", new we(Wn));
+  }
+  async getBodyData() {
+    var w;
+    if (!this.landmarker || !this.sourceCanvas)
+      return;
+    const t = this.downscaler.draw(this.sourceCanvas), n = performance.now(), i = Ke(this.numPoses) === "IMAGE" ? this.landmarker.detect(t) : this.landmarker.detectForVideo(t, n), r = performance.now();
+    this.processingTime = r - n, this.recordInference(n, r);
+    const o = i.landmarks, a = o == null ? void 0 : o[0];
+    this.recordDetections(
+      (o == null ? void 0 : o.length) ?? 0,
+      a && a.length ? a.reduce((M, x) => M + (x.visibility ?? 0), 0) / a.length : null
+    );
+    const d = [], l = [], h = [], m = Se((w = this.getSource) == null ? void 0 : w.call(this));
+    if (o)
+      return o.forEach((M, x) => {
+        var T;
+        d[x] || (d[x] = [], l[x] = []), M.forEach((R) => {
+          d[x].push(ue(R)), l[x].push(R.visibility ?? 1);
+        });
+        const b = (((T = i.worldLandmarks) == null ? void 0 : T[x]) ?? []).map(
+          (R) => yn(R)
+        );
+        b.length === M.length && (h[x] = wn(
+          { world: b, image: d[x], visibility: l[x] },
+          m,
+          n
+        ));
+      }), {
+        coordinatesList: d,
+        visibilityList: l,
+        poses: h
+      };
+  }
+  async processBodyTracking() {
+    var t;
+    if (!(this.disposed || this.paused || !this.landmarker)) {
+      if (!this.reconfiguring && this.shouldRunInference()) {
+        const n = await this.getBodyData();
+        if (n) {
+          this.coordinates = n.coordinatesList, this.visibility = n.visibilityList, this.poses = n.poses;
+          const i = this.sourceCanvas, r = i && i.height > 0 ? i.width / i.height : 1;
+          this.bodies = this.identity.update(
+            n.poses.filter(Boolean),
+            ((t = n.poses.find(Boolean)) == null ? void 0 : t.timestampMs) ?? performance.now(),
+            r
+          );
+        }
+      }
+      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, this.poses = [], this.bodies = [], this.identity.reset(), this.bodyRequests.clear(), this.getSource = 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];
+  }
+  getBodyPose(t = 0) {
+    return this.poses[t] ?? null;
+  }
+  getBodyPoseById(t) {
+    var n;
+    return ((n = this.bodies.find((i) => i.id === t)) == null ? void 0 : n.pose) ?? null;
+  }
+  /** Records `owner`'s wish for `count` bodies; the landmarker looks for the most asked. */
+  requestBodies(t, n) {
+    return this.bodyRequests.set(t, n), this.applyNumBodies(), () => {
+      this.bodyRequests.delete(t) && this.applyNumBodies();
+    };
+  }
+  async applyNumBodies() {
+    const t = Mt(this.bodyRequests.values(), Tt.body.max);
+    if (!(t === this.numPoses || this.disposed || this.reconfiguring || !this.landmarker)) {
+      this.reconfiguring = !0;
+      try {
+        await this.landmarker.setOptions({ numPoses: t, runningMode: Ke(t) }), this.numPoses = t;
+      } catch (n) {
+        console.warn("[BodyTrackingModel] numPoses change failed", n);
+        return;
+      } finally {
+        this.reconfiguring = !1;
+      }
+      this.applyNumBodies();
+    }
+  }
+  async initialize(t) {
+    const n = await $.forVisionTasks(
+      new URL("/assets/xr/wasm", W.assetStorageEndpoint).toString()
+    ), [i] = await Promise.all([
+      ee(
+        new URL("/assets/xr/models/body_tracking.task", W.assetStorageEndpoint).toString()
+      ),
+      te(n)
+    ]);
+    t != null && t.numPoses && this.bodyRequests.set("options", t.numPoses);
+    const r = Mt(this.bodyRequests.values(), Tt.body.max);
+    this.landmarker = await Ds.createFromOptions(n, {
+      baseOptions: {
+        modelAssetBuffer: i,
+        delegate: "GPU"
+      },
+      runningMode: Ke(r),
+      numPoses: r
+    }), this.numPoses = r, this.applyNumBodies();
+  }
+  async run({
+    sourceCanvas: t,
+    getSource: n,
+    targetFps: i,
+    analysisScale: r
+  }) {
+    this.getSource = n, this.setAnalysisScale(r), this.downscaler.setScale(this.analysisScale), this.sourceCanvas = t, this.setTargetFps(i), this.rafId === null && await this.processBodyTracking();
+  }
+  getModelNode() {
+    const t = this;
+    return {
+      getLandmarks2D: this.getLandmarks2D.bind(this),
+      getVisibility: this.getVisibility.bind(this),
+      getBodyPose: this.getBodyPose.bind(this),
+      getBodies: () => this.bodies,
+      getBodyPoseById: this.getBodyPoseById.bind(this),
+      requestBodies: this.requestBodies.bind(this),
+      get numBodies() {
+        return t.numPoses;
+      }
+    };
+  }
+  async getPerformanceData() {
+    return {
+      name: this.constructor.name,
+      processingTime: this.processingTime
+    };
+  }
+}
+const Yt = Symbol("xr.modelNodeSource"), zr = (e) => e[Yt] ?? e, Vn = 0.11, Kn = 4e-3, Gn = "/assets/xr/models/face_tracking.task", Xn = "/assets/xr/wasm", Yn = (e, s, t = !0) => t ? s.set(e.x, -e.y, e.z) : s.set(e.x, e.y, -e.z), jn = (e, s) => s.setFromRotationMatrix(e).normalize();
+class Qn extends se {
+  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 z.Matrix4());
+    u(this, "rotQuatScratch", new z.Quaternion());
+    u(this, "rotEulerScratch", new z.Euler());
+  }
+  extractAndUpdateFaceData(t) {
+    var r;
+    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 i = Se((r = this.getSource) == null ? void 0 : r.call(this));
+    for (; this.faces.length < n; )
+      this.faces.push({
+        transform: {
+          position: new z.Vector3(),
+          rotation: new z.Vector3(),
+          quaternion: new z.Quaternion(),
+          scale: new z.Vector3()
+        },
+        gestures: {},
+        mirrored: i
+      }), this.leftCheekScratch.push(new z.Vector3()), this.rightCheekScratch.push(new z.Vector3());
+    for (let o = 0; o < n; o += 1)
+      this.faces[o].mirrored = i;
+    for (let o = 0; o < n; o += 1) {
+      if (!this.cameras[o])
+        continue;
+      const a = this.faces[o], d = t.faceLandmarks[o], l = t.facialTransformationMatrixes[o];
+      this.rotMatrixScratch.fromArray(l.data), jn(this.rotMatrixScratch, a.transform.quaternion), this.rotQuatScratch.copy(a.transform.quaternion), this.rotQuatScratch.set(
+        -this.rotQuatScratch.x,
+        this.rotQuatScratch.y,
+        this.rotQuatScratch.z,
+        this.rotQuatScratch.w
+      ), this.rotEulerScratch.setFromQuaternion(this.rotQuatScratch, "XYZ"), Yn(this.rotEulerScratch, a.transform.rotation, i), qe(d[4], this.cameras[o], a.transform.position), qe(d[50], this.cameras[o], this.leftCheekScratch[o]), qe(d[280], this.cameras[o], this.rightCheekScratch[o]);
+      const m = this.leftCheekScratch[o].distanceTo(this.rightCheekScratch[o]) * Vn, w = Math.abs(z.MathUtils.radToDeg(this.rotEulerScratch.y)), M = m + w * Kn, x = a.transform.scale.x, b = Dn(
+        isNaN(x) ? 0 : x,
+        M
+      );
+      a.transform.scale.set(b, b, b);
+      const T = a.gestures, R = t.faceBlendshapes[o].categories;
+      for (const y of R)
+        T[y.categoryName] = y.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 = Jn(this.numFaces) * this.analysisScale, n = this.sourceCanvas.width, i = this.sourceCanvas.height, r = Math.min(1, t / Math.max(n, i)), o = Math.max(1, Math.round(n * r)), a = Math.max(1, Math.round(i * r));
+    (!this.analysisCanvas || this.analysisCanvas.width !== o || this.analysisCanvas.height !== a) && (this.analysisCanvas = new OffscreenCanvas(o, a));
+    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, o, a), d.drawImage(this.sourceCanvas, 0, 0, o, a);
+    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, i, r, o;
+    if (this.detectionResults)
+      return {
+        landmarks: (n = this.detectionResults.faceLandmarks) == null ? void 0 : n[t],
+        blendshapes: (r = (i = this.detectionResults.faceBlendshapes) == null ? void 0 : i[t]) == null ? void 0 : r.categories,
+        transformationMatrix: (o = this.detectionResults.facialTransformationMatrixes) == null ? void 0 : o[t]
+      };
+  }
+  async initialize(t) {
+    var o;
+    this.numFaces = (t == null ? void 0 : t.numFaces) || 1;
+    const n = await $.forVisionTasks(
+      new URL(Xn, W.assetStorageEndpoint).toString()
+    );
+    (o = this.modelBytes) == null || o.release();
+    const i = Bn(
+      new URL(Gn, W.assetStorageEndpoint).toString()
+    );
+    this.modelBytes = i;
+    let r;
+    try {
+      const [a] = await Promise.all([i.bytes, te(n)]);
+      r = await Os.createFromOptions(n, {
+        baseOptions: {
+          modelAssetBuffer: a,
+          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 (a) {
+      throw this.releaseModelBytes(i), a;
+    }
+    if (this.disposed) {
+      r.close(), this.releaseModelBytes(i);
+      return;
+    }
+    this.landmarker = r;
+  }
+  releaseModelBytes(t = this.modelBytes) {
+    t == null || t.release(), this.modelBytes === t && (this.modelBytes = null);
+  }
+  async run({
+    sourceCanvas: t,
+    getSource: n,
+    targetFps: i,
+    analysisScale: r
+  }) {
+    this.sourceCanvas = t, this.getSource = n, this.setTargetFps(i), this.setAnalysisScale(r), 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: (i, r = 0) => {
+        this.cameras[r] = i;
+      }
+    };
+    return Object.defineProperty(n, Yt, { value: t }), n;
+  }
+  async getPerformanceData() {
+    return {
+      name: this.constructor.name,
+      processingTime: this.processingTime
+    };
+  }
+}
+const Jn = (e) => e > 1 ? 1024 : 512;
+var Y = /* @__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))(Y || {});
+const Zn = 512, $n = {
+  Closed_Fist: Y.ClosedFist,
+  Open_Palm: Y.OpenPalm,
+  Pointing_Up: Y.PointingUp,
+  Thumb_Down: Y.ThumbDown,
+  Thumb_Up: Y.ThumbUp,
+  Victory: Y.Victory,
+  ILoveYou: Y.ILoveYou,
+  None: Y.None
+}, ei = 15;
+class ti extends se {
+  constructor() {
+    super();
+    u(this, "landmarker", null);
+    u(this, "processingTime", null);
+    u(this, "coordinates");
+    u(this, "gesture");
+    u(this, "sourceCanvas");
+    u(this, "downscaler", new we(Zn));
+  }
+  async getGestureData() {
+    var d, l;
+    if (!this.landmarker || !this.sourceCanvas)
+      return;
+    const t = this.downscaler.draw(this.sourceCanvas), n = performance.now(), i = this.landmarker.recognizeForVideo(t, n), r = performance.now();
+    this.processingTime = r - n, this.recordInference(n, r), this.recordDetections(i.landmarks.length, ((l = (d = i.gestures[0]) == null ? void 0 : d[0]) == null ? void 0 : l.score) ?? null);
+    const o = i.landmarks[0], a = [];
+    if (o) {
+      const h = i.gestures[0][0].categoryName;
+      return o.forEach((m) => {
+        a.push(ue(m));
+      }), {
+        coordinates: a,
+        gesture: $n[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 $.forVisionTasks(
+      new URL("/assets/xr/wasm", W.assetStorageEndpoint).toString()
+    ), [n] = await Promise.all([
+      ee(
+        new URL(
+          "/assets/xr/models/gesture_tracking.task",
+          W.assetStorageEndpoint
+        ).toString()
+      ),
+      te(t)
+    ]), i = await Ls.createFromOptions(t, {
+      baseOptions: {
+        modelAssetBuffer: n,
+        delegate: "GPU"
+      },
+      runningMode: "VIDEO",
+      numHands: 1
+    });
+    this.landmarker = i;
+  }
+  async run({ sourceCanvas: t, targetFps: n, analysisScale: i }) {
+    this.setAnalysisScale(i), this.downscaler.setScale(this.analysisScale), this.sourceCanvas = t, this.setTargetFps(n ?? ei), 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 si extends se {
+  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 we(je().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", Qs());
+    u(this, "builder", new Zs());
+    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 i = this.builder.getOptions().analysisMaxDimension;
+    i !== n && (this.downscaler.dispose(), this.downscaler = new we(i), this.downscaler.setScale(this.analysisScale));
+  }
+  async initialize(t) {
+    this.status = "loading", this.error = null, this.setRuntimeOptions(t ?? {});
+    try {
+      const n = await $.forVisionTasks(
+        new URL("/assets/xr/wasm", W.assetStorageEndpoint).toString()
+      ), [i] = await Promise.all([
+        ee((t == null ? void 0 : t.modelUrl) ?? Nt),
+        te(n)
+      ]);
+      this.vision = n, this.modelBuffer = i, 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 r = await this.createLandmarker(this.delegate);
+      if (this.disposed) {
+        r.close();
+        return;
+      }
+      this.landmarker = r, 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 Ns.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 i = await this.createLandmarker("CPU");
+      if (this.disposed) {
+        i.close();
+        return;
+      }
+      this.landmarker = i, this.delegate = "CPU", this.status = "ready", this.error = null;
+      try {
+        n == null || n.close();
+      } catch {
+      }
+      this.rebuilding = !1, this.detectOnce();
+    } catch (i) {
+      this.rebuilding = !1, this.status = "error", this.error = i instanceof Error ? i : new Error(String(i));
+    }
+  }
+  /** 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 i, r, o, a, 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 = ((i = l.faceLandmarks) != null && i.length ? 1 : 0) + ((r = l.leftHandLandmarks) != null && r.length ? 1 : 0) + ((o = l.rightHandLandmarks) != null && o.length ? 1 : 0) + ((a = l.poseLandmarks) != null && a.length ? 1 : 0), m = (d = l.poseLandmarks) == null ? void 0 : d[0];
+      this.recordDetections(
+        h,
+        m && m.length ? m.reduce((w, M) => w + (M.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 Se((t = this.getSource) == null ? void 0 : t.call(this));
+  }
+  async run({
+    sourceCanvas: t,
+    getSource: n,
+    targetFps: i,
+    analysisScale: r
+  }) {
+    this.sourceCanvas = t, this.getSource = n, this.setTargetFps(i), this.setAnalysisScale(r), 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 ni = (e) => e === "left" ? "right" : "left", ii = (e, s) => s ? ni(e) : e, ri = /left|right|Left|Right/, ai = {
+  left: "right",
+  right: "left",
+  Left: "Right",
+  Right: "Left"
+}, oi = (e) => e.replace(ri, (s) => ai[s]), Wr = (e, s) => s ? oi(e) : e, qr = (e) => e ? -1 : 1, ci = [
+  "wrist",
+  "thumbCmc",
+  "thumbMcp",
+  "thumbIp",
+  "thumbTip",
+  "indexMcp",
+  "indexPip",
+  "indexDip",
+  "indexTip",
+  "middleMcp",
+  "middlePip",
+  "middleDip",
+  "middleTip",
+  "ringMcp",
+  "ringPip",
+  "ringDip",
+  "ringTip",
+  "pinkyMcp",
+  "pinkyPip",
+  "pinkyDip",
+  "pinkyTip"
+], Vr = Object.fromEntries(
+  ci.map((e, s) => [e, s])
+), li = 200, fe = (e, s) => Math.hypot(e.x - s.x, e.y - s.y), ge = (e) => e === "left" ? "right" : "left", Ge = (e, s, t) => ({
+  handedness: s,
+  score: e.score,
+  world: e.world,
+  image: e.image,
+  timestampMs: t,
+  held: !1
+}), di = (e, s, t, {
+  holdMs: n = li,
+  confidentScore: i = 0.8,
+  continuityMs: r = 500
+} = {}) => {
+  const o = (l) => !!l && t - l.timestampMs <= r && l.image.length > 0, a = { 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, w = l.score >= i && h.score >= i;
+    let M;
+    if (m && w)
+      M = l.handedness;
+    else if (o(s.left) && o(s.right)) {
+      const x = fe(l.image[0], s.left.image[0]) + fe(h.image[0], s.right.image[0]), b = fe(l.image[0], s.right.image[0]) + fe(h.image[0], s.left.image[0]);
+      M = x <= b ? "left" : "right";
+    } else if (m)
+      M = l.handedness;
+    else {
+      const x = l.score >= h.score ? l : h, b = x.handedness ?? "right";
+      M = x === l ? b : ge(b);
+    }
+    a[M] = Ge(l, M, t), a[ge(M)] = Ge(h, ge(M), t);
+  } else if (d.length === 1) {
+    const [l] = d;
+    let h = l.handedness ?? "right";
+    if (l.score < i || l.handedness === void 0) {
+      const m = (x) => o(x) ? fe(l.image[0], x.image[0]) : 1 / 0, w = m(s[h]);
+      m(s[ge(h)]) < w && (h = ge(h));
+    }
+    a[h] = Ge(l, h, t);
+  }
+  for (const l of ["left", "right"]) {
+    const h = s[l];
+    a[l] || !h || t - h.timestampMs <= n && (a[l] = { ...h, held: !0 });
+  }
+  return a;
+}, hi = (e, s) => {
+  const t = e == null ? void 0 : e.toLowerCase();
+  if (!(t !== "left" && t !== "right"))
+    return ii(t, s);
+}, ui = (e, s = { x: 0, y: 0, z: 0 }) => (s.x = e.x * 100, s.y = -e.y * 100, s.z = -e.z * 100, s), mi = 512, fi = Object.freeze({
+  minHandDetectionConfidence: 0.5,
+  minHandPresenceConfidence: 0.65,
+  minTrackingConfidence: 0.5
+});
+class gi extends se {
+  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 we(mi));
+  }
+  async getHandData() {
+    var m, w, M;
+    if (!this.landmarker || !this.sourceCanvas)
+      return;
+    const t = this.downscaler.draw(this.sourceCanvas), n = performance.now(), i = this.landmarker.detectForVideo(t, n), r = performance.now();
+    this.processingTime = r - n, this.recordInference(n, r);
+    const o = [], a = [], d = i.handedness ?? i.handednesses ?? [];
+    this.recordDetections(i.landmarks.length, ((w = (m = d[0]) == null ? void 0 : m[0]) == null ? void 0 : w.score) ?? null);
+    const l = Se((M = this.getSource) == null ? void 0 : M.call(this));
+    if (i.landmarks.forEach((x, b) => {
+      var A, E;
+      if (!x || x.length === 0)
+        return;
+      const T = x.map(
+        (B) => ue(B)
+      ), R = (((A = i.worldLandmarks) == null ? void 0 : A[b]) ?? []).map(
+        (B) => ui(B)
+      ), y = (E = d[b]) == null ? void 0 : E[0], g = hi(y == null ? void 0 : y.categoryName, l), p = (y == null ? void 0 : y.score) ?? 0, v = x[0].z < 0 ? "closed_fist" : "open_palm";
+      o.push({ coordinates: T, worldCoordinates: R, gesture: v, handedness: g, handednessScore: p }), a.push({
+        handedness: g,
+        score: p,
+        world: R,
+        image: T
+      });
+    }), this.poses = di(a, this.poses, n), !o.length)
+      return {
+        hands: void 0,
+        coordinates: void 0,
+        gesture: void 0,
+        handedness: void 0
+      };
+    const h = o[0];
+    return {
+      hands: o,
+      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 $.forVisionTasks(
+      new URL("/assets/xr/wasm", W.assetStorageEndpoint).toString()
+    ), [n] = await Promise.all([
+      ee(
+        new URL("/assets/xr/models/hand_tracking.task", W.assetStorageEndpoint).toString()
+      ),
+      te(t)
+    ]), i = await Bs.createFromOptions(t, {
+      baseOptions: {
+        modelAssetBuffer: n,
+        delegate: "GPU"
+      },
+      runningMode: "VIDEO",
+      numHands: 2,
+      ...fi
+    });
+    this.landmarker = i;
+  }
+  async run({
+    sourceCanvas: t,
+    getSource: n,
+    targetFps: i,
+    analysisScale: r
+  }) {
+    this.getSource = n, this.setAnalysisScale(r), this.downscaler.setScale(this.analysisScale), this.sourceCanvas = t, this.setTargetFps(i), 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 pi = 24, yi = 720, wi = [
+  [255, 255, 255, 255],
+  // 0: the person → white
+  [0, 0, 0, 0]
+  // 1
+];
+class vi extends se {
+  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, i = t.height;
+    return typeof n == "number" && n > 0 && typeof i == "number" && i > 0 ? { width: n, height: i } : 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, yi / Math.max(t.width, t.height)), i = Math.max(1, Math.round(t.width * n)), r = Math.max(1, Math.round(t.height * n));
+    this.processCanvas.width === i && this.processCanvas.height === r || (this.processCanvas.width = i, this.processCanvas.height = r, this.glCanvas && (this.glCanvas.width = i, this.glCanvas.height = r), 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 i = this.processCanvas.getContext("2d");
+    if (i) {
+      const d = this.processCanvas.width, l = this.processCanvas.height;
+      if (i.clearRect(0, 0, d, l), this.inputSource && this.inputSourceSize) {
+        const { width: h, height: m } = this.inputSourceSize, w = Math.min(d / h, l / m), M = h * w, x = m * w;
+        i.drawImage(this.inputSource, (d - M) / 2, (l - x) / 2, M, x);
+      } else
+        i.drawImage(t, 0, 0, d, l);
+    }
+    const r = performance.now(), a = this.segmenter.segmentForVideo(this.processCanvas, r).categoryMask;
+    if (!a) {
+      if (this.disposed || this.paused) return;
+      this.rafId = requestAnimationFrame(this.processSegmentation.bind(this));
+      return;
+    }
+    if (this.rawCache = null, this.latestMaskTimeMs = r, this.latestMask && (this.latestMask.close(), this.latestMask = null), this.useGpuMaskPath && this.drawingUtils && this.glCanvas)
+      this.drawingUtils.drawCategoryMask(a, wi), this.latestMask = a.clone(), a.close(), this.blitGlToMask();
+    else {
+      this.latestMask = a.clone();
+      const d = this.readMaskToImageData(a);
+      a.close(), d && this.blitImageDataToMask(d);
+    }
+    this.segmentationMaskTexture && (this.isMaskSetup || (this.segmentationMaskTexture.format = Ot, this.segmentationMaskTexture.minFilter = Re, this.segmentationMaskTexture.magFilter = Re, 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 ImageData build (only when the GPU path is off). The
+   * single-channel mask is expanded to RGBA with green and alpha 255 on the
+   * person and 0 on the background, like the GPU path (green carries the
+   * signal for the alphaMap).
+   */
+  readMaskToImageData(t) {
+    const n = t.getAsUint8Array(), { width: i, height: r } = t;
+    if (!n || i <= 0 || r <= 0) return null;
+    (!this.maskImageData || this.maskImageData.width !== i || this.maskImageData.height !== r) && (this.maskImageData = new ImageData(i, r));
+    const o = this.maskImageData.data;
+    for (let a = 0; a < n.length; a += 1) {
+      const d = n[a] === 255 ? 0 : 255;
+      o[a * 4] = 255, o[a * 4 + 1] = d, o[a * 4 + 2] = 255, o[a * 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"), i = this.filterCanvas.getContext("2d");
+    if (!n || !i) return;
+    const r = this.getStagingCanvas(t.width, t.height), o = r.getContext("2d");
+    o && (o.putImageData(t, 0, 0), i.filter = "blur(0.5px)", i.clearRect(0, 0, this.filterCanvas.width, this.filterCanvas.height), i.drawImage(r, 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 $.forVisionTasks(
+      new URL("/assets/xr/wasm", W.assetStorageEndpoint).toString()
+    ), [i] = await Promise.all([
+      ee(
+        new URL("/assets/xr/models/segmentation.tflite", W.assetStorageEndpoint).toString()
+      ),
+      te(n)
+    ]);
+    this.glCanvas = new OffscreenCanvas(1, 1);
+    const r = this.glCanvas.getContext("webgl2", {
+      preserveDrawingBuffer: !0
+    });
+    this.segmenter = await Dt.createFromOptions(n, {
+      baseOptions: {
+        modelAssetBuffer: i,
+        delegate: "GPU"
+      },
+      ...r ? { canvas: this.glCanvas } : {},
+      outputCategoryMask: !0,
+      outputConfidenceMasks: !1,
+      runningMode: "VIDEO"
+    }), r ? (this.drawingUtils = new Hs(r), this.useGpuMaskPath = !0) : this.useGpuMaskPath = !1;
+  }
+  async run({
+    sourceCanvas: t,
+    renderWidth: n,
+    renderHeight: i,
+    targetFps: r
+  }) {
+    var a;
+    if (!t)
+      return;
+    this.setTargetFps(r ?? pi), this.isProcessing = !1, this.rafId !== null && (cancelAnimationFrame(this.rafId), this.rafId = null);
+    const o = this.getQualityScaleFactor();
+    this.sourceCanvas = t, this.processCanvas = document.createElement("canvas"), this.processCanvas.width = t.width * o, this.processCanvas.height = t.height * o, this.glCanvas && (this.glCanvas.width = this.processCanvas.width, this.glCanvas.height = this.processCanvas.height), this.maskImageData = void 0, this.maskCanvas = document.createElement("canvas"), this.maskCanvas.width = n, this.maskCanvas.height = i, this.filterCanvas = document.createElement("canvas"), this.filterCanvas.width = n, this.filterCanvas.height = i, (a = this.segmentationMaskTexture) == null || a.dispose(), this.segmentationMaskTexture = new Lt(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(),
+      getMaskTimestampMs: () => t.latestMaskTimeMs,
+      setInputSource: (n) => t.setInputSource(n ?? void 0)
+    };
+  }
+  async getPerformanceData() {
+    return {
+      name: this.constructor.name,
+      processingTime: this.processingTime
+    };
+  }
+}
+const xi = (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
+}), Kr = (e) => {
+  e.indices.fill(0);
+}, Gr = (e, s) => e.labels.indexOf(s), Si = (e, s, t) => {
+  const { width: n, height: i, indices: r } = e, o = s.length;
+  if (o < 3) return;
+  let a = 1 / 0, d = -1 / 0;
+  for (let w = 0; w < o; w += 1) {
+    const M = s[w].y * i;
+    M < a && (a = M), M > d && (d = M);
+  }
+  const l = Math.max(0, Math.floor(a)), h = Math.min(i - 1, Math.ceil(d)), m = [];
+  for (let w = l; w <= h; w += 1) {
+    const M = w + 0.5;
+    m.length = 0;
+    for (let b = 0; b < o; b += 1) {
+      const T = s[b], R = s[(b + 1) % o], y = T.y * i, g = R.y * i;
+      if (M < y == M < g) continue;
+      const p = (M - y) / (g - y);
+      m.push((T.x + p * (R.x - T.x)) * n);
+    }
+    m.sort((b, T) => b - T);
+    const x = w * n;
+    for (let b = 0; b + 1 < m.length; b += 2) {
+      const T = Math.max(0, Math.round(m[b])), R = Math.min(n, Math.round(m[b + 1]));
+      for (let y = T; y < R; y += 1) r[x + y] = t;
+    }
+  }
+}, Xr = (e, s, t, n, i = []) => {
+  i.length = 0;
+  for (let r = 0; r < t.length; r += 1) {
+    const o = s[t[r]];
+    if (!o) return;
+    i.push(o);
+  }
+  Si(e, i, n);
+}, Xe = (e) => e, At = {
+  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: Xe
+  },
+  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: Xe
+  },
+  // Fingernails: the MIT-licensed tiny U-Net from nngeek195/nail-segmentation-v1
+  // (Hugging Face), re-exported to TFLite float16 with the input normalisation
+  // baked in (0..1 RGB, as MediaPipe feeds it) and a two-class output
+  // (assets-src/nail-segmenter). Fixed input
+  // 128 × 224 (w × h): MediaPipe stretches the feed to it.
+  nails: {
+    labels: ["bg", "nail"],
+    assetPath: "/assets/xr/models/nail_segmenter_v1.tflite",
+    defaultUrl: "https://cdn.vincentt.studio/assets/xr/models/nail_segmenter_v1.tflite",
+    decode: Xe
+  }
+}, Mi = (e, s, t) => {
+  const n = t.length === e.length ? t : new Uint8Array(e.length);
+  for (let i = 0; i < e.length; i += 1) n[i] = s(e[i]);
+  return n;
+}, bi = 15, ki = { low: 0.5, medium: 0.75, high: 1 };
+class Ci extends se {
+  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", xi(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 = At[this.preset];
+    this.mask.labels = n.labels, this.status = "loading", this.error = null;
+    try {
+      const i = await $.forVisionTasks(
+        new URL("/assets/xr/wasm", W.assetStorageEndpoint).toString()
+      ), r = (t == null ? void 0 : t.modelUrl) ?? n.defaultUrl, [o] = await Promise.all([
+        ee(r),
+        te(i)
+      ]);
+      this.segmenter = await Dt.createFromOptions(i, {
+        baseOptions: { modelAssetBuffer: o, delegate: "GPU" },
+        outputCategoryMask: !0,
+        outputConfidenceMasks: !1,
+        runningMode: "VIDEO"
+      }), this.status = "ready";
+    } catch (i) {
+      throw this.status = "error", this.error = i instanceof Error ? i : new Error(String(i)), this.error;
+    }
+  }
+  async run({ sourceCanvas: t, targetFps: n }) {
+    t && (this.setTargetFps(n ?? bi), 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: i } = this;
+    if (!t || !n || !i || !this.shouldRunInference()) {
+      this.rafId = requestAnimationFrame(this.process.bind(this));
+      return;
+    }
+    const r = performance.now(), o = ki[this.quality], a = Math.max(1, Math.round(n.width * o)), d = Math.max(1, Math.round(n.height * o));
+    (i.width !== a || i.height !== d) && (i.width = a, i.height = d);
+    const l = i.getContext("2d");
+    l && l.drawImage(n, 0, 0, a, d);
+    try {
+      const m = t.segmentForVideo(i, performance.now()).categoryMask;
+      if (m) {
+        const w = 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 = Mi(
+          w,
+          At[this.preset].decode,
+          this.mask.indices
+        ), this.mask.version += 1, this.mask.timestampMs = r, 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() - r, this.recordInference(r), !(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 It = {
+  [F.BACKGROUND_SEGMENTATION]: vi,
+  [F.SEMANTIC_SEGMENTATION]: Ci,
+  [F.HAND_TRACKER]: gi,
+  [F.GESTURE_TRACKER]: ti,
+  [F.FACE_TRACKER]: Qn,
+  [F.BODY_TRACKER]: qn,
+  [F.HOLISTIC_TRACKER]: si
+}, Ti = 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 i = setTimeout(n, 150), r = () => {
+      clearTimeout(i), n();
+    };
+    typeof t.requestVideoFrameCallback == "function" ? t.requestVideoFrameCallback(r) : requestAnimationFrame(() => requestAnimationFrame(() => r()));
+  }), s;
+}, Ei = (e) => {
+  const s = new Lt(e);
+  return s.colorSpace = Vs, s.format = Ot, s.minFilter = Re, s.magFilter = Re, s.generateMipmaps = !1, s.needsUpdate = !0, s;
+}, Ri = (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 i = s.getContext("2d", {
+    colorSpace: "srgb"
+  });
+  i.save(), i.scale(-1, 1), i.drawImage(e, -s.width, 0, s.width, s.height), i.restore();
+}, Ai = (e, s, t = 1) => {
+  const n = s.getContext("2d", {
+    colorSpace: "srgb"
+  }), i = un({
+    source: { width: e.width, height: e.height },
+    feed: { width: s.width, height: s.height },
+    zoom: t
+  });
+  i && (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,
+    i.offsetX,
+    i.offsetY,
+    i.drawWidth,
+    i.drawHeight
+  ));
+}, Ii = (e, s, t) => {
+  const n = /* @__PURE__ */ new Map(), i = /* @__PURE__ */ new WeakSet();
+  let r = !1;
+  const o = (y, g) => {
+    const p = e.getSnapshot().modelErrors;
+    if (g === null && !p.has(y)) return;
+    const v = new Map(p);
+    g === null ? v.delete(y) : v.set(y, { model: y, error: g, at: performance.now() }), e.set({ modelErrors: v });
+  }, a = (y, g) => {
+    var p;
+    try {
+      (p = g.dispose) == null || p.call(g);
+    } catch (v) {
+      console.warn(`[xr-sdk registry] dispose threw for ${y}`, v);
+    }
+  };
+  return {
+    acquire: async (y, g, p) => {
+      let v = n.get(y);
+      if (v)
+        return v.refs.add(g), v.activeRefs.add(g), v.initPromise;
+      const A = s[y];
+      if (!A)
+        throw new Error(`Invalid model: ${y}`);
+      const E = new A(), B = /* @__PURE__ */ new Set([g]), K = /* @__PURE__ */ new Set([g]);
+      o(y, null);
+      const O = (async () => {
+        await E.initialize(p);
+        const I = n.get(y);
+        if (!I || I.model !== E || I.refs.size === 0)
+          return a(y, E), E;
+        t && await t(y, E);
+        const G = n.get(y);
+        return G && G.refs.size > 0 && (i.add(E), e.setPipeline((X) => X.set(y, E))), E;
+      })();
+      return v = { model: E, refs: B, activeRefs: K, initPromise: O, options: p }, n.set(y, v), O.catch((I) => {
+        n.get(y) === v && (n.delete(y), e.setPipeline((X) => X.delete(y)), o(y, I instanceof Error ? I : new Error(String(I)))), a(y, E);
+      }), O;
+    },
+    release: (y, g) => {
+      const p = n.get(y);
+      p && (p.refs.delete(g), p.activeRefs.delete(g) && p.refs.size > 0 && p.activeRefs.size === 0 && p.model.pause(), !(p.refs.size > 0) && (n.delete(y), a(y, p.model), e.setPipeline((v) => v.delete(y))));
+    },
+    setActive: (y, g, p) => {
+      const v = n.get(y);
+      if (!v || !v.refs.has(g)) return;
+      const A = v.activeRefs.size > 0;
+      p ? v.activeRefs.add(g) : v.activeRefs.delete(g);
+      const E = v.activeRefs.size > 0;
+      A !== E && (E && !r ? v.model.resume() : v.model.pause());
+    },
+    suspendAll: () => {
+      r = !0;
+      for (const y of n.values())
+        y.model.pause();
+    },
+    resumeActive: () => {
+      r = !1;
+      for (const y of n.values())
+        y.activeRefs.size > 0 && y.model.resume();
+    },
+    get: (y) => {
+      var g;
+      return (g = n.get(y)) == null ? void 0 : g.model;
+    },
+    getOptions: (y) => {
+      var g;
+      return (g = n.get(y)) == null ? void 0 : g.options;
+    },
+    releaseAll: () => {
+      for (const y of Array.from(n.keys())) {
+        const g = n.get(y);
+        g && (g.refs.clear(), n.delete(y), a(y, g.model));
+      }
+      e.setPipeline((y) => y.clear());
+    },
+    getState: (y) => {
+      const g = n.get(y);
+      return g ? i.has(g.model) ? "ready" : "initializing" : e.getSnapshot().modelErrors.has(y) ? "error" : "idle";
+    },
+    getOwners: (y) => {
+      const g = n.get(y);
+      return {
+        refs: g ? Array.from(g.refs) : [],
+        active: g ? Array.from(g.activeRefs) : []
+      };
+    }
+  };
+}, Fi = {
+  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
+}, Pi = () => {
+  let e = { ...Fi, pipeline: /* @__PURE__ */ new Map(), modelErrors: /* @__PURE__ */ new Map() };
+  const s = /* @__PURE__ */ new Set(), t = () => {
+    s.forEach((n) => n());
+  };
+  return {
+    getSnapshot: () => e,
+    set: (n) => {
+      let i = !1;
+      for (const r of Object.keys(n))
+        if (n[r] !== e[r]) {
+          i = !0;
+          break;
+        }
+      i && (e = { ...e, ...n }, t());
+    },
+    setPipeline: (n) => {
+      const i = new Map(e.pipeline);
+      return n(i), e = { ...e, pipeline: i }, t(), i;
+    },
+    subscribe: (n) => (s.add(n), () => {
+      s.delete(n);
+    })
+  };
+}, Ft = (e, s) => s ?? e === "user", _i = ({
+  renderHeight: e,
+  renderWidth: s,
+  videoHeight: t,
+  videoWidth: n
+}) => ({
+  height: e || t,
+  width: s || n
+}), Di = (e, s) => {
+  const t = new fn({ verbose: !0 }), n = Pi();
+  n.set({ cameraZoom: (e == null ? void 0 : e.cameraZoom) ?? 1.2 });
+  let i = s, r = e;
+  const o = (c) => {
+    var S;
+    const f = (S = q.getOptions(c)) == null ? void 0 : S.targetFps;
+    return typeof f == "number" ? f : r == null ? void 0 : r.targetFps;
+  };
+  let a, d, l, h, m, w, M, x, b, T, R, y, g = !1, p = !1, v = !1, A = 0, E, B, K, O = !1, I = 0, G = /* @__PURE__ */ new WeakSet();
+  const X = /* @__PURE__ */ new Set(), Me = (c) => {
+    const f = n.getSnapshot().cameraTexture;
+    f && f.dispose();
+    const S = Ei(c);
+    return n.set({ cameraTexture: S }), S;
+  }, Ie = async (c, f) => {
+    if (G.has(f) || n.getSnapshot().lifecycle !== "running" || !m) return;
+    G.add(f);
+    const S = I;
+    try {
+      await f.run({
+        sourceCanvas: m,
+        renderWidth: n.getSnapshot().renderWidth,
+        renderHeight: n.getSnapshot().renderHeight,
+        getSource: () => n.getSnapshot().sourceKind,
+        targetFps: o(c),
+        analysisScale: r == null ? void 0 : r.analysisScale
+      }), O && (await new Promise((k) => requestAnimationFrame(() => k())), await new Promise((k) => requestAnimationFrame(() => k())), O && I === S && q.suspendAll());
+    } catch (k) {
+      throw G.delete(f), k;
+    }
+  }, q = Ii(n, It, (c, f) => Ie(c, f));
+  n.subscribe(() => {
+    if (n.getSnapshot().lifecycle !== "running") return;
+    const c = n.getSnapshot().pipeline;
+    for (const [f, S] of c.entries())
+      G.has(S) || Ie(f, S);
+  });
+  const st = () => {
+    y !== void 0 && (cancelAnimationFrame(y), y = void 0);
+  }, ne = () => {
+    if (st(), E == null || E(), E = void 0, d) {
+      try {
+        d.pause();
+      } catch {
+      }
+      try {
+        d.srcObject = null;
+      } catch {
+      }
+      d = void 0;
+    }
+    if (l) {
+      try {
+        l.getTracks().forEach((c) => c.stop());
+      } catch {
+      }
+      l = void 0;
+    }
+  }, Fe = () => {
+    if (g || !d || !h || !m) return;
+    const c = typeof window < "u" ? window.__xr_debugger_metrics : void 0;
+    if (c != null && c.trackCameraFrame && c.trackCameraFrame(), Se(n.getSnapshot().sourceKind))
+      Ri(d, h);
+    else {
+      const C = h.getContext("2d");
+      if (!C) return;
+      const D = d.videoWidth, L = d.videoHeight;
+      h.width !== D && (h.width = D), h.height !== L && (h.height = L), C.setTransform(1, 0, 0, 1, 0, 0), C.clearRect(0, 0, D, L), C.drawImage(d, 0, 0, D, L);
+    }
+    Ai(h, m, (r == null ? void 0 : r.cameraZoom) ?? 1.2);
+    const S = n.getSnapshot();
+    (S.sourceWidth !== d.videoWidth || S.sourceHeight !== d.videoHeight) && n.set({ sourceWidth: d.videoWidth, sourceHeight: d.videoHeight }), A += 1, A % 10 === 0 && n.set({ feedFrames: A });
+    const k = n.getSnapshot().cameraTexture;
+    k && (k.needsUpdate = !0);
+  }, Pe = () => {
+    if (!d || !h || !m) return;
+    if (O) {
+      Fe();
+      return;
+    }
+    const c = () => {
+      y = requestAnimationFrame(c), Fe();
+    };
+    y = requestAnimationFrame(c);
+  }, ts = async (c, f) => {
+    if (c.source === P.WEBCAM)
+      try {
+        const S = r != null && r.camRes && r.camRes > 0 ? r.camRes : 960;
+        n.set({ cameraPermission: "requesting", cameraPermissionReason: null });
+        const k = c.deviceId ? { deviceId: { exact: c.deviceId } } : { facingMode: { ideal: c.facingMode ?? "user" } }, C = {
+          frameRate: { min: 24, ideal: 30, max: 60 },
+          width: { ideal: S },
+          ...k
+        };
+        let D;
+        try {
+          D = await navigator.mediaDevices.getUserMedia({ video: C });
+        } catch (L) {
+          if (!(L instanceof DOMException && L.name === "OverconstrainedError")) throw L;
+          D = await navigator.mediaDevices.getUserMedia({
+            video: { frameRate: { ideal: 30 }, width: { ideal: S }, ...k }
+          });
+        }
+        return f === I && n.set({ cameraPermission: "granted", cameraPermissionReason: null }), D;
+      } catch (S) {
+        const k = zt(S), C = St[k], D = await Wt(), L = qt(k, D.state);
+        throw f === I && n.set({
+          error: { error: "PermissionError", message: C, reason: k },
+          cameraPermission: L.state,
+          cameraPermissionReason: L.reason
+        }), new N(S instanceof Error ? S.message : "getUserMedia failed");
+      }
+    return c.stream;
+  }, nt = (c) => {
+    const { lifecycle: f } = n.getSnapshot();
+    f === "idle" || f === "stopped" || g || (ne(), q.suspendAll(), I += 1, a = void 0, n.set({
+      lifecycle: "stopped",
+      ready: !1,
+      error: { error: "PermissionError", message: St[c], reason: c },
+      cameraPermission: c === "permission-denied" ? "blocked" : "unavailable",
+      cameraPermissionReason: Ut(c)
+    }), t.log("XR session stopped: camera lost.", c));
+  }, ss = (c) => {
+    var k;
+    E == null || E();
+    const f = ((k = c.getVideoTracks) == null ? void 0 : k.call(c)) ?? [], S = () => {
+      l === c && nt("camera-lost");
+    };
+    f.forEach((C) => {
+      var D;
+      return (D = C.addEventListener) == null ? void 0 : D.call(C, "ended", S);
+    }), E = () => {
+      f.forEach((C) => {
+        var D;
+        return (D = C.removeEventListener) == null ? void 0 : D.call(C, "ended", S);
+      });
+    };
+  }, ns = async () => {
+    if (B || typeof navigator > "u") return;
+    const c = navigator.permissions;
+    if (c != null && c.query)
+      try {
+        const f = await c.query({ name: "camera" });
+        if (p) return;
+        B = f, K = () => {
+          f.state === "denied" && (a == null ? void 0 : a.source) === P.WEBCAM && nt("permission-denied");
+        }, f.addEventListener("change", K);
+      } catch {
+      }
+  }, is = () => {
+    var c;
+    B && K && ((c = B.removeEventListener) == null || c.call(B, "change", K)), B = void 0, K = void 0;
+  }, _e = async (c) => {
+    var ft, be, gt;
+    const f = I, S = await ts(c, f);
+    if (f !== I)
+      throw S.getTracks().forEach((oe) => oe.stop()), new N("Media source superseded by a newer bind");
+    l = S, ss(S);
+    const k = await Ti(S);
+    if (f !== I || p)
+      throw S.getTracks().forEach((oe) => oe.stop()), new N("Media source superseded by a newer bind");
+    d = k, h = new OffscreenCanvas(k.videoWidth, k.videoHeight);
+    const { renderWidth: C, renderHeight: D } = n.getSnapshot(), L = _i({
+      renderWidth: C,
+      renderHeight: D,
+      videoWidth: k.videoWidth,
+      videoHeight: k.videoHeight
+    });
+    m ? (m.width !== L.width || m.height !== L.height) && (m.width = L.width, m.height = L.height, Me(m)) : (m = new OffscreenCanvas(L.width, L.height), Me(m));
+    const mt = c.source === P.STREAM ? c.static === !0 : !1;
+    O = mt;
+    const ae = (gt = (be = (ft = S.getVideoTracks) == null ? void 0 : ft.call(S)[0]) == null ? void 0 : be.getSettings) == null ? void 0 : gt.call(be), Be = ae == null ? void 0 : ae.facingMode, Rs = Be === "user" || Be === "environment" ? Be : null;
+    if (c.source === P.WEBCAM) {
+      const oe = Rs ?? c.facingMode ?? "user", pt = Ft(oe, c.mirrored);
+      a = {
+        source: P.WEBCAM,
+        sourceKind: pt ? "webcam" : "rear-camera",
+        facingMode: oe,
+        deviceId: c.deviceId,
+        mirrored: pt
+      };
+    } else
+      a = {
+        source: P.STREAM,
+        stream: c.stream,
+        static: mt,
+        sourceKind: c.sourceKind ?? "webcam"
+      };
+    n.set({
+      source: c.source,
+      sourceKind: a.sourceKind,
+      cameraFacing: a.source === P.WEBCAM ? a.facingMode : null,
+      cameraDeviceId: a.source === P.WEBCAM ? (ae == null ? void 0 : ae.deviceId) ?? a.deviceId ?? null : null,
+      sourceWidth: k.videoWidth,
+      sourceHeight: k.videoHeight,
+      error: void 0
+    }), c.source === P.WEBCAM && ns();
+  }, De = async (c) => {
+    const f = c.sourceKind ?? "webcam";
+    m = c.canvas;
+    const S = Me(m);
+    n.set({
+      cameraTexture: S,
+      source: P.CANVAS,
+      sourceKind: f,
+      cameraFacing: null,
+      cameraDeviceId: null,
+      renderWidth: m.width,
+      renderHeight: m.height,
+      error: void 0
+    }), a = {
+      source: P.CANVAS,
+      canvas: c.canvas,
+      sourceKind: f
+    };
+  }, rs = (c, f) => {
+    if (!f || c.source !== f.source) return !1;
+    if (c.source === P.STREAM && f.source === P.STREAM)
+      return c.stream === f.stream && (c.sourceKind ?? "webcam") === f.sourceKind;
+    if (c.source === P.WEBCAM && f.source === P.WEBCAM) {
+      const S = c.facingMode ?? "user";
+      return S === f.facingMode && c.deviceId === f.deviceId && Ft(S, c.mirrored) === f.mirrored;
+    }
+    return !1;
+  }, it = async () => {
+    if (!m) return;
+    const c = I, f = n.getSnapshot().pipeline;
+    for (const [, S] of f.entries())
+      S.resume();
+    await new Promise((S) => requestAnimationFrame(() => S())), await new Promise((S) => requestAnimationFrame(() => S())), O && I === c && q.suspendAll();
+  }, as = (c, f) => !f || f.source !== P.CANVAS ? !1 : c.canvas === f.canvas && (c.sourceKind ?? "webcam") === f.sourceKind, Oe = async (c) => {
+    const f = c.source;
+    if (f !== P.WEBCAM && f !== P.STREAM)
+      throw new N(`Invalid media source: ${String(f)}`);
+    if (p) throw new N("session.setMediaSource() called after the provider unmounted");
+    if (rs(c, a)) {
+      t.log("Media source unchanged, skipping rebind.");
+      return;
+    }
+    I += 1;
+    const { lifecycle: S } = n.getSnapshot();
+    if (S === "idle" || S === "stopped") {
+      await _e(c), n.set({ lifecycle: "media-bound" }), t.log("Media source set to:", c.source);
+      return;
+    }
+    if (S === "media-bound") {
+      ne(), await _e(c), t.log("Media source rebound to:", c.source);
+      return;
+    }
+    const k = S === "paused";
+    g = !0, await new Promise((C) => requestAnimationFrame(() => C())), ne();
+    try {
+      await _e(c);
+    } finally {
+      g = !1;
+    }
+    if (k) {
+      d == null || d.pause(), t.log("Media source swapped (paused) to:", c.source);
+      return;
+    }
+    Pe(), O ? await it() : q.resumeActive(), t.log("Media source swapped to:", c.source);
+  }, os = async (c) => {
+    if (p) throw new N("session.setFrameSource() called after the provider unmounted");
+    if (as(c, a)) {
+      t.log("Frame source unchanged, skipping rebind.");
+      return;
+    }
+    I += 1;
+    const { lifecycle: f } = n.getSnapshot();
+    if (f === "idle" || f === "stopped") {
+      await De(c), n.set({ lifecycle: "media-bound" }), t.log("Frame source set to canvas.");
+      return;
+    }
+    if (f === "media-bound") {
+      ne(), await De(c), t.log("Frame source rebound to canvas.");
+      return;
+    }
+    g = !0, await new Promise((S) => requestAnimationFrame(() => S())), ne();
+    try {
+      await De(c);
+    } finally {
+      g = !1;
+    }
+    t.log("Frame source swapped to canvas.");
+  }, rt = async () => {
+    if (p) throw new N("session.start() called after the provider unmounted");
+    const { lifecycle: c } = n.getSnapshot();
+    if (c === "running") return;
+    if (c === "paused") {
+      await Le();
+      return;
+    }
+    if (c === "idle")
+      throw new N("session.start() called before setMediaSource — call setMediaSource first");
+    if (!m)
+      throw new N("session.start(): media source not bound");
+    const f = (a == null ? void 0 : a.source) === P.CANVAS;
+    if (!f && (!d || !h))
+      throw c === "stopped" ? new N(
+        "session.start() called from stopped state without a media source — call setMediaSource first"
+      ) : new N("session.start(): media source not bound");
+    f || Pe(), q.resumeActive(), n.set({ lifecycle: "running" }), await new Promise((k) => requestAnimationFrame(() => k()));
+    const S = n.getSnapshot().pipeline;
+    for (const [k, C] of S.entries())
+      await Ie(k, C);
+    n.set({ ready: !0 }), t.log("XR session started.");
+  }, at = () => {
+    if (n.getSnapshot().lifecycle === "running") {
+      st(), q.suspendAll();
+      try {
+        d == null || d.pause();
+      } catch {
+      }
+      n.set({ lifecycle: "paused" }), t.log("XR session paused.");
+    }
+  }, Le = async () => {
+    if (p) throw new N("session.resume() called after the provider unmounted");
+    n.getSnapshot().lifecycle === "paused" && (v = !1, d && d.play().catch(() => {
+    }), (a == null ? void 0 : a.source) !== P.CANVAS && Pe(), n.set({ lifecycle: "running" }), O ? await it() : q.resumeActive(), t.log("XR session resumed."));
+  }, cs = async (c = {}) => {
+    await Oe({ source: P.WEBCAM, ...c });
+    const { lifecycle: f } = n.getSnapshot();
+    return (f === "media-bound" || f === "stopped") && await rt(), n.getSnapshot().cameraFacing ?? c.facingMode ?? "user";
+  }, ot = async () => {
+    const { lifecycle: c } = n.getSnapshot();
+    c === "stopped" || c === "idle" || (v = !1, ne(), q.suspendAll(), a = void 0, n.set({ lifecycle: "stopped", ready: !1 }), t.log("XR session stopped."));
+  }, ct = async () => {
+    await ot(), q.releaseAll(), X.clear();
+    const c = n.getSnapshot().cameraTexture;
+    c && c.dispose(), G = /* @__PURE__ */ new WeakSet(), a = void 0, I += 1, m = void 0, h = void 0, M = void 0, O = !1, is(), 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.");
+  }, ls = async () => {
+    p || (p = !0, re == null || re(), re = void 0, ie == null || ie(), ie = void 0, await ct(), t.log("XR session disposed."));
+  }, ds = () => {
+    p && (p = !1, ut(), ht(), t.log("XR session re-armed."));
+  }, hs = () => p, us = async (c) => {
+    const f = "legacy:registerXRPipeline", S = [];
+    await Promise.all(
+      c.map(async (k) => {
+        const { model: C } = k;
+        if (!It[C])
+          throw new N(`Invalid model: ${C}`);
+        X.has(C) || S.push(C);
+        const D = "options" in k ? k.options : void 0;
+        await q.acquire(C, f, D);
+      })
+    ), S.length > 0 && (S.forEach((k) => X.add(k)), t.log("XR pipeline registered."));
+  }, ms = (c) => {
+    const f = q.get(c);
+    if (!f)
+      throw new N(`Model ${c} is not registered in the pipeline`);
+    return f.getModelNode();
+  }, lt = async (c, f) => {
+    c <= 0 || f <= 0 || (n.set({ renderWidth: c, renderHeight: f }), m && (m.width !== c || m.height !== f) && (m.width = c, m.height = f, Me(m), O && Fe()), t.log(`Source canvas set. Render size: ${c}x${f}`));
+  }, fs = async (c) => {
+    var C;
+    w = c;
+    const f = (C = c.getBoundingClientRect) == null ? void 0 : C.call(c), S = f && f.width > 0 ? Math.round(f.width) : c.clientWidth, k = f && f.height > 0 ? Math.round(f.height) : c.clientHeight;
+    await lt(S, k);
+  }, gs = (c) => {
+    M = c;
+  }, Ne = () => w && x && b && T ? w : M, ps = (c) => {
+    x = c.renderer, b = c.scene, T = c.camera, R = c.renderFrame;
+  }, dt = () => {
+    if (!x || !b || !T)
+      throw new N(
+        "XR frame render requested before the R3F state was bound — make sure <XRScene> is mounted"
+      );
+    R ? R() : x.render(b, T);
+  }, ys = () => {
+    const c = w;
+    if (c && Ne() === c)
+      return dt(), c.toDataURL("image/png");
+    const f = Ne();
+    if (f) return f.toDataURL("image/png");
+    throw new N(
+      "session.captureFrame() called before an XRScene or XRMediaSurface capture target was bound"
+    );
+  }, ws = (c = 30) => {
+    const f = Ne();
+    if (!(f != null && f.captureStream))
+      throw new N(
+        "session.captureStream() called before an XRScene or XRMediaSurface capture target was bound"
+      );
+    return f.captureStream(c);
+  }, vs = () => d, xs = () => m ?? null, Ss = (c) => {
+    if (r = c, n.set({ cameraZoom: (c == null ? void 0 : c.cameraZoom) ?? 1.2 }), n.getSnapshot().lifecycle !== "running" || !m) return;
+    const f = n.getSnapshot().pipeline;
+    for (const [S, k] of f.entries())
+      k.run({
+        sourceCanvas: m,
+        renderWidth: n.getSnapshot().renderWidth,
+        renderHeight: n.getSnapshot().renderHeight,
+        getSource: () => n.getSnapshot().sourceKind,
+        targetFps: o(S),
+        analysisScale: r == null ? void 0 : r.analysisScale
+      });
+  }, Ms = () => r, bs = async () => {
+    if (!a || a.source !== P.WEBCAM) return;
+    const { facingMode: c, deviceId: f, mirrored: S } = a;
+    a = void 0, await Oe({ source: P.WEBCAM, facingMode: c, deviceId: f, mirrored: S });
+  }, ks = (c) => {
+    n.set({ quality: c });
+  }, Cs = (c) => {
+    n.set({ qualityConfig: c });
+  }, Ts = (c) => {
+    i = c;
+  }, Es = () => {
+    var C;
+    if (typeof window > "u") return { type: "portrait", angle: 0 };
+    const c = (C = window.screen) == null ? void 0 : C.orientation, f = (c == null ? void 0 : c.angle) ?? 0, S = f === 90 || f === 180 || f === 270 ? f : 0;
+    return { type: c != null && c.type ? c.type.startsWith("landscape") ? "landscape" : "portrait" : window.innerWidth > window.innerHeight ? "landscape" : "portrait", angle: S };
+  }, me = () => {
+    const c = Es(), f = n.getSnapshot().orientation, S = f.type !== c.type || f.angle !== c.angle ? { orientation: c } : {};
+    d && d.videoWidth > 0 && (S.sourceWidth = d.videoWidth, S.sourceHeight = d.videoHeight), Object.keys(S).length && n.set(S);
+  };
+  let ie;
+  const ht = () => {
+    var f, S, k;
+    if (ie || typeof window > "u") return;
+    const c = (f = window.screen) == null ? void 0 : f.orientation;
+    (S = c == null ? void 0 : c.addEventListener) == null || S.call(c, "change", me), (k = window.addEventListener) == null || k.call(window, "resize", me), ie = () => {
+      var C, D;
+      (C = c == null ? void 0 : c.removeEventListener) == null || C.call(c, "change", me), (D = window.removeEventListener) == null || D.call(window, "resize", me);
+    }, me();
+  };
+  let re;
+  const ut = () => {
+    if (re || typeof document > "u" || typeof document.addEventListener != "function") return;
+    const c = () => {
+      if (!p) {
+        if (document.hidden) {
+          i != null && i.pauseWhenHidden && n.getSnapshot().lifecycle === "running" && (at(), v = !0);
+          return;
+        }
+        if (v && n.getSnapshot().lifecycle === "paused") {
+          Le();
+          return;
+        }
+        n.getSnapshot().lifecycle === "running" && (d != null && d.paused) && d.play().catch(() => {
+        });
+      }
+    };
+    document.addEventListener("visibilitychange", c), re = () => document.removeEventListener("visibilitychange", c);
+  };
+  return ut(), ht(), {
+    store: n,
+    registry: q,
+    setMediaSource: Oe,
+    start: rt,
+    stop: ot,
+    reset: ct,
+    pause: at,
+    resume: Le,
+    switchCamera: cs,
+    dispose: ls,
+    rearm: ds,
+    isDisposed: hs,
+    setFrameSource: os,
+    registerXRPipeline: us,
+    getModelNode: ms,
+    captureFrame: ys,
+    captureStream: ws,
+    getInputFrame: xs,
+    _setRenderTarget: fs,
+    _setCaptureTarget: gs,
+    _setRenderSize: lt,
+    _setR3FState: ps,
+    _renderFrame: dt,
+    _getVideoElement: vs,
+    _setPerf: Ss,
+    _setLifecycle: Ts,
+    _rebindMedia: bs,
+    _setQuality: ks,
+    _setQualityConfig: Cs,
+    _getPerf: Ms
+  };
+}, Oi = (e, s) => {
+  const t = he(e), n = he(s), i = xe(
+    () => Di(t.current, n.current),
+    []
+  ), r = JSON.stringify(s ?? {});
+  ye(() => {
+    i._setLifecycle(s);
+  }, [i, r]), ye(() => (i.rearm(), () => void i.dispose()), [i]);
+  const o = JSON.stringify(e ?? {});
+  return ye(() => {
+    i._setPerf(e);
+  }, [i, o]), i;
+}, Ye = /* @__PURE__ */ new Map(), Li = () => ({
+  register: (e, s) => {
+    s ? Ye.set(e, s) : Ye.delete(e);
+  },
+  resolve: (e) => e ? Ye.get(e) ?? null : null
+}), jt = Li(), Qt = _t(null), Ni = ({ children: e }) => {
+  const s = he(/* @__PURE__ */ new Map()), t = wt((r, o) => {
+    o ? s.current.set(r, o) : s.current.delete(r);
+  }, []), n = wt(
+    (r) => r ? s.current.get(r) ?? null : null,
+    []
+  ), i = xe(() => ({ register: t, resolve: n }), [t, n]);
+  return Ps(Qt.Provider, { value: i }, e);
+}, Jt = () => Je(Qt) ?? jt, Yr = () => Jt().register, jr = () => Jt().resolve;
+jt.register;
+const Bi = {
+  [F.FACE_TRACKER]: "face",
+  [F.HAND_TRACKER]: "hand",
+  [F.GESTURE_TRACKER]: "gesture",
+  [F.BODY_TRACKER]: "body",
+  [F.HOLISTIC_TRACKER]: "holistic",
+  [F.BACKGROUND_SEGMENTATION]: "segmentation",
+  [F.SEMANTIC_SEGMENTATION]: "semantic-seg"
+}, Pt = Object.values(F), Hi = (e, s) => {
+  var n;
+  const t = (n = e.registry.getOptions(s)) == null ? void 0 : n.targetFps;
+  return typeof t == "number" ? t : null;
+}, Qe = (e, s, t, n = performance.now()) => {
+  const i = e.store.getSnapshot(), r = t ? n - t.sampledAt : 0, o = t && r > 0 ? Math.max(0, (i.feedFrames - t.feedFrames) * 1e3 / r) : 0, a = i.lifecycle === "running", d = s.map((h) => {
+    var T;
+    const m = e.registry.getState(h), w = e.store.getSnapshot().pipeline.get(h), M = ((T = i.modelErrors.get(h)) == null ? void 0 : T.error) ?? null, x = (w == null ? void 0 : w.getDiagnostics()) ?? {
+      inferenceMs: null,
+      inferenceFps: 0,
+      inferences: 0,
+      skippedFrames: 0,
+      detections: null,
+      confidence: null,
+      status: M ? "error" : "ready",
+      error: M,
+      paused: !1,
+      disposed: !1
+    };
+    let b;
+    return m === "error" || x.status === "error" ? b = "error" : m === "idle" ? b = "unavailable" : m === "initializing" ? b = "loading" : x.paused || !a ? b = "paused" : b = "ready", {
+      ...x,
+      error: x.error ?? M,
+      model: h,
+      label: Bi[h] ?? h,
+      state: b,
+      targetFps: Hi(e, h),
+      owners: e.registry.getOwners(h)
+    };
+  }), l = i.quality;
+  return {
+    quality: l ? {
+      tier: l.decision.tier.name,
+      index: l.index,
+      locked: l.locked,
+      reason: l.decision.reason
+    } : null,
+    session: {
+      lifecycle: i.lifecycle,
+      ready: i.ready,
+      error: i.error,
+      source: i.source,
+      sourceKind: i.sourceKind,
+      sourceWidth: i.sourceWidth,
+      sourceHeight: i.sourceHeight,
+      renderWidth: i.renderWidth,
+      renderHeight: i.renderHeight,
+      feedFps: o,
+      feedFrames: i.feedFrames
+    },
+    models: d,
+    inferenceMsTotal: d.reduce(
+      (h, m) => h + (m.state === "ready" ? m.inferenceMs ?? 0 : 0),
+      0
+    ),
+    sampledAt: n
+  };
+}, Qr = (e = {}) => {
+  const { intervalMs: s = 250, enabled: t = !0 } = e, { session: n } = es(), i = (e.models ?? Pt).join("|"), r = xe(
+    () => e.models && e.models.length ? e.models : Pt,
+    // modelsKey captures the list by value.
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [i]
+  ), o = he(null), [a, d] = _s(
+    () => Qe(n, r, null)
+  );
+  return ye(() => {
+    if (!t) return;
+    const l = () => {
+      const m = Qe(n, r, o.current);
+      o.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, r, s, t]), a;
+}, Ui = [
+  { 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 }
+], Z = {
+  maxFrameMs: 1e3 / 24,
+  maxInferenceMs: 24,
+  maxMemoryMb: null,
+  sampleMs: 1e3,
+  downgradeAfter: 2,
+  upgradeAfter: 6,
+  upgradeHeadroom: 0.75,
+  cooldownMs: 4e3
+}, Zt = {
+  frameMs: null,
+  fps: null,
+  inferenceMs: null,
+  feedFps: null,
+  memoryMb: null,
+  deviceMemoryGb: null,
+  hardwareConcurrency: null,
+  thermal: "unknown"
+}, ve = (e, s, t) => Math.min(t, Math.max(s, e)), H = (e, s) => typeof e == "number" && Number.isFinite(e) ? e : s, zi = (e, s) => ({
+  name: typeof e.name == "string" && e.name ? e.name : `tier-${s}`,
+  ...H(e.targetFps, NaN) > 0 ? { targetFps: H(e.targetFps, 0) } : {},
+  ...H(e.renderScale, NaN) > 0 ? { renderScale: ve(H(e.renderScale, 1), 0.25, 1) } : {},
+  ...H(e.analysisScale, NaN) > 0 ? { analysisScale: ve(H(e.analysisScale, 1), 0.25, 1) } : {},
+  ...H(e.camRes, NaN) > 0 ? { camRes: Math.round(H(e.camRes, 0)) } : {},
+  ...e.rebindCamera ? { rebindCamera: !0 } : {}
+}), Wi = (e = {}) => ({
+  maxFrameMs: Math.max(1, H(e.maxFrameMs, Z.maxFrameMs)),
+  maxInferenceMs: Math.max(
+    0,
+    H(e.maxInferenceMs, Z.maxInferenceMs)
+  ),
+  maxMemoryMb: e.maxMemoryMb === null || e.maxMemoryMb === void 0 ? null : Math.max(1, H(e.maxMemoryMb, 0)) || null,
+  sampleMs: Math.max(100, H(e.sampleMs, Z.sampleMs)),
+  downgradeAfter: Math.max(
+    1,
+    Math.round(H(e.downgradeAfter, Z.downgradeAfter))
+  ),
+  upgradeAfter: Math.max(
+    1,
+    Math.round(H(e.upgradeAfter, Z.upgradeAfter))
+  ),
+  upgradeHeadroom: ve(
+    H(e.upgradeHeadroom, Z.upgradeHeadroom),
+    0.1,
+    1
+  ),
+  cooldownMs: Math.max(0, H(e.cooldownMs, Z.cooldownMs))
+}), Q = (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((i) => i.name === s);
+    if (n >= 0) return n;
+  }
+  return t;
+}, qi = (e = {}) => {
+  const s = e.tiers && e.tiers.length ? e.tiers.map((i, r) => zi(i, r)) : Ui, t = Q(s, e.maxTier, 0), n = Math.max(t, Q(s, e.minTier, s.length - 1));
+  return {
+    tiers: s,
+    budget: Wi(e.budget),
+    ...e.initialTier !== void 0 ? { initialTier: e.initialTier } : {},
+    minTier: n,
+    maxTier: t,
+    adaptive: e.adaptive !== !1,
+    historySize: Math.max(1, Math.round(H(e.historySize, 20)))
+  };
+}, Vi = (e, s) => {
+  const t = Q(e.tiers, e.maxTier, 0), n = Q(e.tiers, e.minTier, e.tiers.length - 1);
+  if (e.initialTier !== void 0)
+    return ve(Q(e.tiers, e.initialTier, t), t, n);
+  const i = s.deviceMemoryGb !== null && s.deviceMemoryGb <= 4 || s.hardwareConcurrency !== null && s.hardwareConcurrency <= 4;
+  return ve(i ? t + 1 : t, t, n);
+}, $t = (e, s = Zt, t = 0) => {
+  const n = Vi(e, s), i = { index: n, tier: e.tiers[n], reason: "init", at: t };
+  return {
+    index: n,
+    locked: !1,
+    badStreak: 0,
+    goodStreak: 0,
+    lastChangeAt: t,
+    decision: i,
+    history: [i],
+    signals: s
+  };
+}, Ae = (e, s, t, n, i, r = e.signals) => {
+  const o = { index: t, tier: s.tiers[t], reason: n, at: i };
+  return {
+    ...e,
+    index: t,
+    badStreak: 0,
+    goodStreak: 0,
+    lastChangeAt: i,
+    decision: o,
+    history: [o, ...e.history].slice(0, s.historySize),
+    signals: r
+  };
+}, Ki = (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, Gi = (e, s, t, n) => {
+  const { budget: i } = t, r = Q(t.tiers, t.maxTier, 0), o = Q(t.tiers, t.minTier, t.tiers.length - 1);
+  if (e.locked || !t.adaptive) return { ...e, signals: s };
+  const a = Ki(s, i), d = a === null && s.frameMs !== null && s.frameMs <= i.maxFrameMs * i.upgradeHeadroom && (s.inferenceMs === null || s.inferenceMs <= i.maxInferenceMs * i.upgradeHeadroom), l = a ? e.badStreak + 1 : 0, h = d ? e.goodStreak + 1 : 0, m = n - e.lastChangeAt >= i.cooldownMs;
+  if (a && l >= i.downgradeAfter && m) {
+    if (e.index < o)
+      return Ae(e, t, e.index + 1, a, n, s);
+    const w = a === "frame-time" ? "suspected" : s.thermal;
+    return { ...e, badStreak: l, goodStreak: h, signals: { ...s, thermal: w } };
+  }
+  return d && h >= i.upgradeAfter && m && e.index > r ? Ae(e, t, e.index - 1, "recovered", n, s) : { ...e, badStreak: l, goodStreak: h, signals: s };
+}, Jr = (e, s, t, n) => {
+  const i = Q(s.tiers, t, e.index);
+  return i === e.index ? e : Ae(e, s, i, "manual", n);
+}, Zr = (e, s, t, n) => t === e.locked ? e : { ...Ae(e, s, e.index, t ? "locked" : "manual", n), locked: t }, Xi = (e, s) => e.decision.tier === s ? null : e.decision.tier, $r = (e, s, t) => {
+  const n = $t(e, s, t);
+  return {
+    ...n,
+    decision: { ...n.decision, reason: "reset" },
+    history: [{ ...n.decision, reason: "reset" }]
+  };
+}, Yi = Object.values(F), ji = () => {
+  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
+  };
+}, Qi = () => {
+  const e = performance.memory;
+  return e ? e.usedJSHeapSize / 1048576 : null;
+}, Ji = ({ config: e, thermal: s, onDecision: t }) => {
+  const { session: n } = es(), i = JSON.stringify(e ?? {}), r = xe(() => qi(e), [i]), o = he(s ?? "unknown");
+  o.current = s ?? "unknown";
+  const a = he(t);
+  return a.current = t, ye(() => {
+    const d = ji();
+    let l = $t(
+      r,
+      { ...Zt, ...d },
+      performance.now()
+    );
+    const h = n.store.getSnapshot().quality;
+    h && h.index < r.tiers.length && (l = {
+      ...h,
+      decision: { ...h.decision, tier: r.tiers[h.index] }
+    }), n._setQualityConfig(r), n._setQuality(l);
+    let m = n._getPerf(), w = null;
+    const M = async (p, v) => {
+      const A = {
+        ...m,
+        ...p.targetFps !== void 0 ? { targetFps: p.targetFps } : {},
+        ...p.analysisScale !== void 0 ? { analysisScale: p.analysisScale } : {},
+        ...p.camRes !== void 0 && p.rebindCamera ? { camRes: p.camRes } : {}
+      };
+      n._setPerf(A), p.rebindCamera && p.camRes !== void 0 && p.camRes !== (v == null ? void 0 : v.camRes) && await n._rebindMedia().catch(() => {
+      });
+    };
+    w = l.decision.tier, M(l.decision.tier, null);
+    let x = 0, b = performance.now(), T = 0;
+    const R = () => {
+      x += 1, T = requestAnimationFrame(R);
+    };
+    T = requestAnimationFrame(R);
+    let y = null;
+    const g = window.setInterval(() => {
+      var G;
+      if (typeof document < "u" && document.hidden) {
+        x = 0, b = performance.now();
+        return;
+      }
+      const p = performance.now(), v = p - b, A = Qe(n, Yi, y, p);
+      y = { feedFrames: A.session.feedFrames, sampledAt: p };
+      const E = n.store.getSnapshot().lifecycle === "running", B = {
+        frameMs: x > 0 && v > 0 && E ? v / x : null,
+        fps: x > 0 && v > 0 ? x * 1e3 / v : null,
+        inferenceMs: E ? A.inferenceMsTotal : null,
+        feedFps: A.session.feedFps,
+        memoryMb: Qi(),
+        ...d,
+        thermal: o.current
+      };
+      x = 0, b = p;
+      const K = n.store.getSnapshot().quality ?? l, O = Gi(K, B, r, p);
+      l = O, n._setQuality(O);
+      const I = Xi(O, w);
+      if (I) {
+        const X = w;
+        w = I, M(I, X), (G = a.current) == null || G.call(a, O);
+      }
+    }, r.budget.sampleMs);
+    return () => {
+      cancelAnimationFrame(T), window.clearInterval(g);
+      const p = (w == null ? void 0 : w.rebindCamera) && w.camRes !== void 0;
+      n._setPerf(m), p && (m == null ? void 0 : m.camRes) !== (w == null ? void 0 : w.camRes) && n._rebindMedia().catch(() => {
+      }), m = void 0, n._setQualityConfig(null);
+    };
+  }, [n, r]), null;
+}, tt = _t(void 0), es = () => {
+  const e = Je(tt);
+  if (!e)
+    throw new N(
+      "XR context can only be used inside XRProvider, did you forget to wrap your app in <XRProvider>?"
+    );
+  return e;
+}, ea = () => Je(tt) ?? null, ta = ({ children: e, perf: s, lifecycle: t, quality: n }) => {
+  const i = Oi(s, t), r = xe(() => ({ session: i }), [i]);
+  return /* @__PURE__ */ Fs(tt.Provider, { value: r, children: [
+    n !== !1 && /* @__PURE__ */ yt(Ji, { config: n || void 0 }),
+    /* @__PURE__ */ yt(Ni, { children: e })
+  ] });
+};
+export {
+  Cr as $,
+  ii as A,
+  pe as B,
+  ue as C,
+  Kr as D,
+  Zt as E,
+  Xr as F,
+  xi as G,
+  ci as H,
+  Ks as I,
+  W as J,
+  pr as K,
+  V as L,
+  J as M,
+  jr as N,
+  yr as O,
+  Ce as P,
+  Ze as Q,
+  Wt as R,
+  At as S,
+  or as T,
+  cr as U,
+  lr as V,
+  dr as W,
+  Tt as X,
+  ta as Y,
+  Cn as Z,
+  Mr as _,
+  Jr as a,
+  kn as a$,
+  Gt as a0,
+  wr as a1,
+  br as a2,
+  Tr as a3,
+  Rn as a4,
+  xr as a5,
+  Rr as a6,
+  Sr as a7,
+  vr as a8,
+  kr as a9,
+  Vt as aA,
+  Nt as aB,
+  Xs as aC,
+  Ys as aD,
+  js as aE,
+  In as aF,
+  Nr as aG,
+  Or as aH,
+  Pn as aI,
+  Gs as aJ,
+  Qe as aK,
+  zt as aL,
+  qt as aM,
+  Qr as aN,
+  Bi as aO,
+  an as aP,
+  $t as aQ,
+  Ki as aR,
+  ji as aS,
+  Vi as aT,
+  Wi as aU,
+  zi as aV,
+  Gi as aW,
+  Xi as aX,
+  Si as aY,
+  Gr as aZ,
+  vn as a_,
+  Er as aa,
+  Pr as ab,
+  mn as ac,
+  Ar as ad,
+  Ir as ae,
+  ur as af,
+  mr as ag,
+  fr as ah,
+  gr as ai,
+  _r as aj,
+  hr as ak,
+  An as al,
+  Fr as am,
+  Hr as an,
+  Ur as ao,
+  ni as ap,
+  oi as aq,
+  Bt as ar,
+  en as as,
+  Ht as at,
+  rr as au,
+  Z as av,
+  Ui as aw,
+  Ji as ax,
+  je as ay,
+  li as az,
+  $r as b,
+  Mt as b0,
+  hi as b1,
+  di as b2,
+  ui as b3,
+  pn as b4,
+  wn as b5,
+  yn as b6,
+  Yr as b7,
+  zr as b8,
+  Bn as b9,
+  Gn as ba,
+  Xn as bb,
+  te as bc,
+  un as c,
+  ir as d,
+  Vr as e,
+  Fn as f,
+  Dr as g,
+  Lr as h,
+  Se as i,
+  F as j,
+  Wr as k,
+  Zr as l,
+  ar as m,
+  _n as n,
+  qe as o,
+  qr as p,
+  Ln as q,
+  qi as r,
+  Ut as s,
+  Br as t,
+  es as u,
+  Nn as v,
+  P as w,
+  ea as x,
+  _ as y,
+  hn as z
+};