@vincentt-xr/sdk 2.0.0-alpha.0

package/dist/index-CYMj26Ej.js

@@ -0,0 +1,1331 @@
+var fe = Object.defineProperty;
+var pe = (i, s, e) => s in i ? fe(i, s, { enumerable: !0, configurable: !0, writable: !0, value: e }) : i[s] = e;
+var h = (i, s, e) => pe(i, typeof s != "symbol" ? s + "" : s, e);
+import { jsx as we } from "react/jsx-runtime";
+import { useMemo as ee, useEffect as ve, createContext as Ce, useContext as Se } from "react";
+import { FilesetResolver as U, PoseLandmarker as ke, FaceLandmarker as ye, GestureRecognizer as Me, HandLandmarker as Te, ImageSegmenter as Re, DrawingUtils as Fe } from "@mediapipe/tasks-vision";
+import * as T from "three";
+import { RGBAFormat as te, LinearFilter as B, CanvasTexture as se, SRGBColorSpace as xe } from "three";
+var y = /* @__PURE__ */ ((i) => (i.WEBCAM = "webcam", i.STREAM = "stream", i.CANVAS = "canvas", i))(y || {}), _ = /* @__PURE__ */ ((i) => (i.HAND_TRACKER = "vincentt.xr.hand-tracker", i.GESTURE_TRACKER = "vincentt.xr.gesture-tracker", i.FACE_TRACKER = "vincentt.xr.face-tracker", i.BODY_TRACKER = "vincentt.xr.body-tracker", i.BACKGROUND_SEGMENTATION = "vincentt.xr.background-segmentation", i))(_ || {});
+const ft = {
+  /** Camera background and segmentation mask. `depthTest` disabled. */
+  BACKGROUND: -1e3,
+  /** Free world-space content. `depthTest` enabled. */
+  WORLD: 0,
+  /** Descendants of `FaceTracker` / `HandTracker` / `BodyTracker`. `depthTest` enabled. */
+  TRACKED: 100,
+  /** Descendants of `ScreenSpaceUI`. `depthTest` disabled. */
+  SCREEN_UI: 1e3
+};
+class F extends Error {
+  constructor(s) {
+    super(s), this.name = "VincenttXRError";
+  }
+}
+const x = {
+  // Pinned to the CDN, NOT build-env-driven: a stale VITE_ASSET_STORAGE_ENDPOINT
+  // baked a now-deleted CloudFront domain into every published bundle, breaking
+  // WASM/model loads at runtime. The host must never come from a mutable env value.
+  assetStorageEndpoint: "https://cdn.vincentt.studio",
+  // Versioned bucket for SDK-shipped reference assets (canonical face model, face textures, etc.).
+  sdkAssetsBaseUrl: "https://cdn.vincentt.studio/assets/sdk/face/v1",
+  loggerPrefix: "[vincentt-xr]:"
+};
+class Ae {
+  constructor(s) {
+    h(this, "options");
+    const e = {
+      verbose: !1,
+      prefix: x.loggerPrefix
+    };
+    this.options = { ...e, ...s };
+  }
+  log(...s) {
+    const { verbose: e, prefix: t } = this.options;
+    e && console.log(t, ...s);
+  }
+  error(...s) {
+    const { verbose: e, prefix: t } = this.options;
+    e && console.error(t, ...s);
+  }
+}
+const D = (i) => i * 2 - 1, K = new T.Vector3(), W = new T.Vector3(), V = ({ x: i, y: s, z: e }, t, n) => {
+  K.set((i - 0.5) * 2, (0.5 - s) * 2, -e), K.unproject(t), W.copy(K).sub(t.position).normalize();
+  const r = -t.position.z / W.z;
+  return n.copy(t.position).addScaledVector(W, r), n;
+}, pt = (i, s) => V(i, s, new T.Vector3()), Ee = (i, s, e = 0.2) => e * s + (1 - e) * i;
+class G {
+  constructor(s) {
+    h(this, "canvas");
+    this.maxDimension = s;
+  }
+  /**
+   * Returns a downscaled copy of `source` capped to `maxDimension` on its
+   * longest side (or `source` unchanged if it's already within the cap, or if a
+   * 2D context can't be obtained). The returned canvas is reused across calls.
+   */
+  draw(s) {
+    const e = s.width, t = s.height, n = Math.min(1, this.maxDimension / Math.max(e, t));
+    if (n >= 1) return s;
+    const r = Math.max(1, Math.round(e * n)), c = Math.max(1, Math.round(t * n));
+    (!this.canvas || this.canvas.width !== r || this.canvas.height !== c) && (this.canvas = new OffscreenCanvas(r, c));
+    const d = this.canvas.getContext("2d");
+    return d ? (d.setTransform(1, 0, 0, 1, 0, 0), d.clearRect(0, 0, r, c), d.drawImage(s, 0, 0, r, c), this.canvas) : s;
+  }
+  dispose() {
+    this.canvas = void 0;
+  }
+}
+const be = {};
+async function Ie(i) {
+  const s = await fetch(i);
+  if (!s.ok)
+    throw new Error(`fetchAndVerify: ${s.status} ${i}`);
+  const e = await s.arrayBuffer(), t = De(i);
+  if (!t)
+    return console.warn(`[xr-sdk integrity] no SRI hash for ${i} — passing through`), e;
+  const n = await _e(e);
+  if (n !== t)
+    throw new Error(
+      `[xr-sdk integrity] SRI mismatch for ${i}: expected ${t}, got ${n}`
+    );
+  return e;
+}
+async function z(i) {
+  const s = await Ie(i);
+  return new Uint8Array(s);
+}
+function De(i) {
+  try {
+    const s = new URL(i);
+    return be[s.pathname];
+  } catch {
+    return;
+  }
+}
+async function _e(i) {
+  const s = await crypto.subtle.digest("SHA-384", i), e = new Uint8Array(s);
+  let t = "";
+  for (let n = 0; n < e.byteLength; n++)
+    t += String.fromCharCode(e[n]);
+  return `sha384-${btoa(t)}`;
+}
+class L {
+  constructor() {
+    h(this, "disposed", !1);
+    h(this, "paused", !1);
+    h(this, "rafId", 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.
+    h(this, "targetFrameIntervalMs", 0);
+    h(this, "lastInferenceMs", 0);
+  }
+  /** 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 ? !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 Pe = 768;
+class Oe extends L {
+  constructor() {
+    super();
+    h(this, "landmarker", null);
+    h(this, "processingTime", null);
+    h(this, "coordinates");
+    h(this, "sourceCanvas");
+    h(this, "downscaler", new G(Pe));
+  }
+  async getBodyData() {
+    if (!this.landmarker || !this.sourceCanvas)
+      return;
+    const e = this.downscaler.draw(this.sourceCanvas), t = performance.now(), n = this.landmarker.detectForVideo(e, t), r = performance.now();
+    this.processingTime = r - t;
+    const c = n.landmarks, d = [];
+    if (c)
+      return c.forEach((m, u) => {
+        d[u] || (d[u] = []), m.forEach((g) => {
+          const f = D(g.x), w = D(1 - g.y), p = D(g.z);
+          d[u].push({ x: f, y: w, z: p });
+        });
+      }), {
+        coordinatesList: d
+      };
+  }
+  async processBodyTracking() {
+    if (this.disposed || !this.landmarker)
+      return;
+    const e = await this.getBodyData();
+    e && (this.coordinates = e.coordinatesList), !(this.disposed || this.paused) && (this.rafId = requestAnimationFrame(this.processBodyTracking.bind(this)));
+  }
+  resume() {
+    this.paused && (super.resume(), this.processBodyTracking());
+  }
+  dispose() {
+    if (super.dispose(), this.landmarker) {
+      try {
+        this.landmarker.close();
+      } catch {
+      }
+      this.landmarker = null;
+    }
+    this.sourceCanvas = void 0, this.downscaler.dispose(), this.coordinates = void 0;
+  }
+  getLandmarks2D(e = 0) {
+    if (this.coordinates)
+      return this.coordinates[e];
+  }
+  async initialize(e) {
+    const t = await U.forVisionTasks(
+      new URL("/assets/xr/wasm", x.assetStorageEndpoint).toString()
+    ), n = await z(
+      new URL("/assets/xr/models/body_tracking.task", x.assetStorageEndpoint).toString()
+    );
+    this.landmarker = await ke.createFromOptions(t, {
+      baseOptions: {
+        modelAssetBuffer: n,
+        delegate: "GPU"
+      },
+      runningMode: "VIDEO",
+      numPoses: (e == null ? void 0 : e.numPoses) || 1
+    });
+  }
+  async run({ sourceCanvas: e }) {
+    this.sourceCanvas = e, this.rafId === null && await this.processBodyTracking();
+  }
+  getModelNode() {
+    return {
+      getLandmarks2D: this.getLandmarks2D.bind(this)
+    };
+  }
+  async getPerformanceData() {
+    return {
+      name: this.constructor.name,
+      processingTime: this.processingTime
+    };
+  }
+}
+const Ue = 0.11, ze = 4e-3;
+class Le extends L {
+  constructor() {
+    super();
+    h(this, "landmarker", null);
+    h(this, "processingTime", null);
+    h(this, "sourceCanvas");
+    h(this, "analysisCanvas");
+    h(this, "getSource");
+    h(this, "detectionResults");
+    h(this, "numFaces", 1);
+    h(this, "cameras", []);
+    // camera object to unproject each face's translation
+    h(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.
+    h(this, "leftCheekScratch", []);
+    h(this, "rightCheekScratch", []);
+    // Reused per-frame landmark used to feed unprojectToZZeroInto with an
+    // x-mirrored copy for non-webcam sources, without allocating a new
+    // landmark array (~468 entries) each frame.
+    h(this, "landmarkScratch", { x: 0, y: 0, z: 0, visibility: 0 });
+    // Reused per-frame rotation scratch (matrix -> quaternion -> mirror -> euler),
+    // allocated once to avoid per-frame churn at 30+ fps.
+    h(this, "rotMatrixScratch", new T.Matrix4());
+    h(this, "rotQuatScratch", new T.Quaternion());
+    h(this, "rotEulerScratch", new T.Euler());
+  }
+  // For non-webcam sources MediaPipe landmarks read as mirrored; flip x in
+  // place into the reused scratch so downstream unprojection sees the
+  // corrected position. Webcam input is already correct, so it's returned
+  // by reference.
+  landmarkForSource(e, t) {
+    return t ? (this.landmarkScratch.x = 1 - e.x, this.landmarkScratch.y = e.y, this.landmarkScratch.z = e.z, this.landmarkScratch.visibility = e.visibility, this.landmarkScratch) : e;
+  }
+  extractAndUpdateFaceData(e) {
+    var n;
+    if (!e.faceLandmarks.length) {
+      this.faces = [];
+      return;
+    }
+    const t = e.faceLandmarks.length;
+    for (this.faces.length > t && (this.faces.length = t, this.leftCheekScratch.length = t, this.rightCheekScratch.length = t); this.faces.length < t; )
+      this.faces.push({
+        transform: {
+          position: new T.Vector3(),
+          rotation: new T.Vector3(),
+          scale: new T.Vector3()
+        },
+        gestures: {}
+      }), this.leftCheekScratch.push(new T.Vector3()), this.rightCheekScratch.push(new T.Vector3());
+    for (let r = 0; r < t; r += 1) {
+      if (!this.cameras[r])
+        continue;
+      const c = this.faces[r], d = (n = this.getSource) == null ? void 0 : n.call(this), m = !(d === "webcam" || !d), u = e.faceLandmarks[r], g = e.facialTransformationMatrixes[r];
+      this.rotMatrixScratch.fromArray(g.data), this.rotQuatScratch.setFromRotationMatrix(this.rotMatrixScratch), this.rotQuatScratch.set(
+        -this.rotQuatScratch.x,
+        this.rotQuatScratch.y,
+        this.rotQuatScratch.z,
+        this.rotQuatScratch.w
+      ), this.rotEulerScratch.setFromQuaternion(this.rotQuatScratch, "XYZ"), c.transform.rotation.set(
+        -this.rotEulerScratch.x,
+        this.rotEulerScratch.y,
+        this.rotEulerScratch.z
+      ), V(
+        this.landmarkForSource(u[4], m),
+        this.cameras[r],
+        c.transform.position
+      ), V(
+        this.landmarkForSource(u[50], m),
+        this.cameras[r],
+        this.leftCheekScratch[r]
+      ), V(
+        this.landmarkForSource(u[280], m),
+        this.cameras[r],
+        this.rightCheekScratch[r]
+      );
+      const w = this.leftCheekScratch[r].distanceTo(this.rightCheekScratch[r]) * Ue, p = Math.abs(T.MathUtils.radToDeg(this.rotEulerScratch.y)), k = w + p * ze, C = c.transform.scale.x, R = Ee(
+        isNaN(C) ? 0 : C,
+        k
+      );
+      c.transform.scale.set(R, R, R);
+      const E = c.gestures, b = e.faceBlendshapes[r].categories;
+      for (const A of b)
+        E[A.categoryName] = A.score;
+    }
+  }
+  async processFaceTracking() {
+    if (this.disposed || this.paused || !this.landmarker || !this.sourceCanvas)
+      return null;
+    if (!this.shouldRunInference()) {
+      this.rafId = requestAnimationFrame(this.processFaceTracking.bind(this));
+      return;
+    }
+    const e = Ne(this.numFaces), t = this.sourceCanvas.width, n = this.sourceCanvas.height, r = Math.min(1, e / Math.max(t, n)), c = Math.max(1, Math.round(t * r)), d = Math.max(1, Math.round(n * r));
+    (!this.analysisCanvas || this.analysisCanvas.width !== c || this.analysisCanvas.height !== d) && (this.analysisCanvas = new OffscreenCanvas(c, d));
+    const m = this.analysisCanvas.getContext("2d");
+    if (!m)
+      return;
+    m.setTransform(1, 0, 0, 1, 0, 0), m.clearRect(0, 0, c, d), m.drawImage(this.sourceCanvas, 0, 0, c, d);
+    const u = performance.now(), g = this.landmarker.detectForVideo(this.analysisCanvas, u), f = performance.now();
+    this.processingTime = f - u, this.detectionResults = g, this.extractAndUpdateFaceData(g), !(this.disposed || this.paused) && (this.rafId = requestAnimationFrame(this.processFaceTracking.bind(this)));
+  }
+  resume() {
+    this.paused && (super.resume(), this.processFaceTracking());
+  }
+  getFace(e = 0) {
+    return this.faces[e];
+  }
+  getDetectionResults() {
+    return this.detectionResults;
+  }
+  getRawFaceTrackingData(e = 0) {
+    var t, n, r, c;
+    if (this.detectionResults)
+      return {
+        landmarks: (t = this.detectionResults.faceLandmarks) == null ? void 0 : t[e],
+        blendshapes: (r = (n = this.detectionResults.faceBlendshapes) == null ? void 0 : n[e]) == null ? void 0 : r.categories,
+        transformationMatrix: (c = this.detectionResults.facialTransformationMatrixes) == null ? void 0 : c[e]
+      };
+  }
+  async initialize(e) {
+    this.numFaces = (e == null ? void 0 : e.numFaces) || 1;
+    const t = await U.forVisionTasks(
+      new URL("/assets/xr/wasm", x.assetStorageEndpoint).toString()
+    ), n = await z(
+      new URL("/assets/xr/models/face_tracking.task", x.assetStorageEndpoint).toString()
+    ), r = await ye.createFromOptions(t, {
+      baseOptions: {
+        modelAssetBuffer: n,
+        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
+    });
+    this.landmarker = r;
+  }
+  async run({ sourceCanvas: e, getSource: t, targetFps: n }) {
+    this.sourceCanvas = e, this.getSource = t, this.setTargetFps(n), this.analysisCanvas = void 0, this.rafId === null && this.processFaceTracking();
+  }
+  getModelNode() {
+    const e = this, t = {
+      get detectionResults() {
+        return e.detectionResults;
+      },
+      getDetectionResults: this.getDetectionResults.bind(this),
+      getFace: this.getFace.bind(this),
+      getRawFaceTrackingData: this.getRawFaceTrackingData.bind(this)
+    };
+    return Object.assign(t, {
+      _setCamera: (n, r) => {
+        this.cameras[r] = n;
+      }
+    }), t;
+  }
+  async getPerformanceData() {
+    return {
+      name: this.constructor.name,
+      processingTime: this.processingTime
+    };
+  }
+}
+const Ne = (i) => i > 1 ? 1024 : 512;
+var I = /* @__PURE__ */ ((i) => (i.ClosedFist = "closed_fist", i.OpenPalm = "open_palm", i.PointingUp = "pointing_up", i.ThumbDown = "thumb_down", i.ThumbUp = "thumb_up", i.Victory = "victory", i.ILoveYou = "i_love_you", i.None = "none", i))(I || {});
+const Ve = 512, Be = {
+  Closed_Fist: I.ClosedFist,
+  Open_Palm: I.OpenPalm,
+  Pointing_Up: I.PointingUp,
+  Thumb_Down: I.ThumbDown,
+  Thumb_Up: I.ThumbUp,
+  Victory: I.Victory,
+  ILoveYou: I.ILoveYou,
+  None: I.None
+}, He = 15;
+class qe extends L {
+  constructor() {
+    super();
+    h(this, "landmarker", null);
+    h(this, "processingTime", null);
+    h(this, "coordinates");
+    h(this, "gesture");
+    h(this, "sourceCanvas");
+    h(this, "downscaler", new G(Ve));
+  }
+  async getGestureData() {
+    if (!this.landmarker || !this.sourceCanvas)
+      return;
+    const e = this.downscaler.draw(this.sourceCanvas), t = performance.now(), n = this.landmarker.recognizeForVideo(e, t), r = performance.now();
+    this.processingTime = r - t;
+    const c = n.landmarks[0], d = [];
+    if (c) {
+      const m = n.gestures[0][0].categoryName;
+      return c.forEach((u) => {
+        d.push({
+          x: D(u.x),
+          y: D(1 - u.y),
+          z: -u.z
+        });
+      }), {
+        coordinates: d,
+        gesture: Be[m]
+      };
+    }
+    return { coordinates: void 0, gesture: void 0 };
+  }
+  async processGestureTracking() {
+    if (!this.disposed) {
+      if (this.shouldRunInference()) {
+        const e = await this.getGestureData();
+        e && (this.coordinates = e.coordinates, this.gesture = e.gesture);
+      }
+      this.disposed || this.paused || (this.rafId = requestAnimationFrame(this.processGestureTracking.bind(this)));
+    }
+  }
+  resume() {
+    this.paused && (super.resume(), this.processGestureTracking());
+  }
+  dispose() {
+    if (super.dispose(), this.landmarker) {
+      try {
+        this.landmarker.close();
+      } catch {
+      }
+      this.landmarker = null;
+    }
+    this.sourceCanvas = void 0, this.downscaler.dispose(), this.coordinates = void 0, this.gesture = void 0;
+  }
+  async initialize() {
+    const e = await U.forVisionTasks(
+      new URL("/assets/xr/wasm", x.assetStorageEndpoint).toString()
+    ), t = await z(
+      new URL("/assets/xr/models/gesture_tracking.task", x.assetStorageEndpoint).toString()
+    ), n = await Me.createFromOptions(e, {
+      baseOptions: {
+        modelAssetBuffer: t,
+        delegate: "GPU"
+      },
+      runningMode: "VIDEO",
+      numHands: 1
+    });
+    this.landmarker = n;
+  }
+  async run({ sourceCanvas: e, targetFps: t }) {
+    this.sourceCanvas = e, this.setTargetFps(t ?? He), this.rafId === null && await this.processGestureTracking();
+  }
+  getModelNode() {
+    const e = this;
+    return {
+      get coordinates() {
+        return e.coordinates;
+      },
+      get gesture() {
+        return e.gesture;
+      }
+    };
+  }
+  async getPerformanceData() {
+    return {
+      name: this.constructor.name,
+      processingTime: this.processingTime
+    };
+  }
+}
+const Ke = 512;
+class We extends L {
+  constructor() {
+    super();
+    h(this, "landmarker", null);
+    h(this, "processingTime", null);
+    h(this, "coordinates");
+    h(this, "gesture");
+    h(this, "sourceCanvas");
+    h(this, "downscaler", new G(Ke));
+  }
+  async getHandData() {
+    if (!this.landmarker || !this.sourceCanvas)
+      return;
+    const e = this.downscaler.draw(this.sourceCanvas), t = performance.now(), n = this.landmarker.detectForVideo(e, t), r = performance.now();
+    this.processingTime = r - t;
+    const c = n.landmarks[0], d = [];
+    if (c) {
+      const m = n.landmarks[0][0].z < 0 ? "closed_fist" : "open_palm";
+      return c.forEach((u) => {
+        d.push({
+          x: D(u.x),
+          y: D(1 - u.y),
+          z: -u.z
+        });
+      }), {
+        coordinates: d,
+        gesture: m
+      };
+    }
+    return { coordinates: void 0, gesture: void 0 };
+  }
+  async processHandTracking() {
+    if (!this.disposed) {
+      if (this.shouldRunInference()) {
+        const e = await this.getHandData();
+        e && (this.coordinates = e.coordinates, this.gesture = e.gesture);
+      }
+      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.downscaler.dispose(), this.coordinates = void 0, this.gesture = void 0;
+  }
+  async initialize() {
+    const e = await U.forVisionTasks(
+      new URL("/assets/xr/wasm", x.assetStorageEndpoint).toString()
+    ), t = await z(
+      new URL("/assets/xr/models/hand_tracking.task", x.assetStorageEndpoint).toString()
+    ), n = await Te.createFromOptions(e, {
+      baseOptions: {
+        modelAssetBuffer: t,
+        delegate: "GPU"
+      },
+      runningMode: "VIDEO",
+      numHands: 1
+    });
+    this.landmarker = n;
+  }
+  async run({ sourceCanvas: e, targetFps: t }) {
+    this.sourceCanvas = e, this.setTargetFps(t), this.rafId === null && await this.processHandTracking();
+  }
+  getModelNode() {
+    const e = this;
+    return {
+      get coordinates() {
+        return e.coordinates;
+      },
+      get gesture() {
+        return e.gesture;
+      }
+    };
+  }
+  async getPerformanceData() {
+    return {
+      name: this.constructor.name,
+      processingTime: this.processingTime
+    };
+  }
+}
+const Ge = 24, Xe = 720, $e = [
+  [255, 255, 255, 255],
+  // 0: background → green 255, kept
+  [0, 0, 0, 0]
+  // 1: person → green 0, discarded
+];
+class Ye extends L {
+  constructor() {
+    super();
+    h(this, "segmenter", null);
+    h(this, "processingTime", null);
+    h(this, "sourceCanvas");
+    // input source canvas
+    h(this, "processCanvas");
+    // downscaled canvas of sourceCanvas for processing
+    h(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.
+    h(this, "inputSource");
+    h(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.)
+    h(this, "glCanvas");
+    h(this, "drawingUtils");
+    h(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.
+    h(this, "maskImageData");
+    h(this, "maskCanvas", null);
+    h(this, "segmentationMaskTexture");
+    h(this, "isMaskSetup", !1);
+    h(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.
+    h(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.
+    h(this, "rawCache", null);
+    h(this, "quality", "medium");
+    h(this, "stagingCanvas");
+  }
+  getQualityScaleFactor() {
+    switch (this.quality) {
+      case "low":
+        return 0.5;
+      case "medium":
+        return 0.75;
+      case "high":
+        return 1;
+      default:
+        return 0.5;
+    }
+  }
+  /**
+   * Set (or clear) a high-resolution input override. Pass the raw <video>/<img>
+   * (or any CanvasImageSource with intrinsic dimensions) to run segmentation on
+   * native-resolution, uncropped frames instead of the small display-fit session
+   * feed. Pass `undefined` to revert to the shared feed canvas.
+   */
+  setInputSource(e) {
+    this.inputSource = e, this.inputSourceSize = e ? this.readIntrinsicSize(e) : void 0;
+  }
+  readIntrinsicSize(e) {
+    if (e instanceof HTMLVideoElement)
+      return e.videoWidth > 0 ? { width: e.videoWidth, height: e.videoHeight } : void 0;
+    if (e instanceof HTMLImageElement)
+      return e.naturalWidth > 0 ? { width: e.naturalWidth, height: e.naturalHeight } : void 0;
+    const t = e.width, n = e.height;
+    return typeof t == "number" && t > 0 && typeof n == "number" && n > 0 ? { width: t, height: n } : void 0;
+  }
+  /**
+   * Size the process canvas to the override input's aspect ratio, bounded by
+   * PROCESS_MAX_DIM on the long edge, and keep the GL canvas in sync so the GPU
+   * mask renders at the same resolution. No-op when there is no override, or when
+   * the intrinsic size hasn't changed since the last frame.
+   */
+  ensureProcessCanvasForInput() {
+    if (!this.processCanvas || !this.inputSource) return;
+    const e = this.readIntrinsicSize(this.inputSource);
+    if (!e) return;
+    this.inputSourceSize = e;
+    const t = Math.min(1, Xe / Math.max(e.width, e.height)), n = Math.max(1, Math.round(e.width * t)), r = Math.max(1, Math.round(e.height * t));
+    this.processCanvas.width === n && this.processCanvas.height === r || (this.processCanvas.width = n, this.processCanvas.height = r, this.glCanvas && (this.glCanvas.width = n, 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 e = this.inputSource ?? this.sourceCanvas;
+    if (!this.segmenter || !e) {
+      if (this.disposed || this.paused) return;
+      this.rafId = requestAnimationFrame(this.processSegmentation.bind(this));
+      return;
+    }
+    const t = performance.now();
+    this.ensureProcessCanvasForInput();
+    const n = this.processCanvas.getContext("2d");
+    if (n) {
+      const d = this.processCanvas.width, m = this.processCanvas.height;
+      if (n.clearRect(0, 0, d, m), this.inputSource && this.inputSourceSize) {
+        const { width: u, height: g } = this.inputSourceSize, f = Math.min(d / u, m / g), w = u * f, p = g * f;
+        n.drawImage(this.inputSource, (d - w) / 2, (m - p) / 2, w, p);
+      } else
+        n.drawImage(e, 0, 0, d, m);
+    }
+    const c = this.segmenter.segmentForVideo(
+      this.processCanvas,
+      performance.now()
+    ).categoryMask;
+    if (!c) {
+      if (this.disposed || this.paused) return;
+      this.rafId = requestAnimationFrame(this.processSegmentation.bind(this));
+      return;
+    }
+    if (this.rawCache = null, this.latestMask && (this.latestMask.close(), this.latestMask = null), this.useGpuMaskPath && this.drawingUtils && this.glCanvas)
+      this.drawingUtils.drawCategoryMask(c, $e), this.latestMask = c.clone(), c.close(), this.blitGlToMask();
+    else {
+      this.latestMask = c.clone();
+      const d = this.readMaskToImageData(c);
+      c.close(), d && this.blitImageDataToMask(d);
+    }
+    this.segmentationMaskTexture && (this.isMaskSetup || (this.segmentationMaskTexture.format = te, this.segmentationMaskTexture.minFilter = B, this.segmentationMaskTexture.magFilter = B, this.segmentationMaskTexture.generateMipmaps = !1, this.isMaskSetup = !0), this.segmentationMaskTexture.needsUpdate = !0), this.processingTime = performance.now() - t, !(this.disposed || this.paused) && (this.rafId = requestAnimationFrame(this.processSegmentation.bind(this)));
+  }
+  /**
+   * Blit the GPU-rendered mask (already RGBA-inverted by drawCategoryMask)
+   * straight from the GL canvas into the mask canvas, cover-fitted through the
+   * soft-edge blur. `drawImage(glCanvas)` is a GPU→GPU transfer — no readPixels,
+   * no CPU array, no ImageData, no row flip (the 2D canvas presents the WebGL
+   * canvas right-side-up). This is the zero-readback path.
+   */
+  blitGlToMask() {
+    if (!this.maskCanvas || !this.filterCanvas || !this.glCanvas) return;
+    const e = this.maskCanvas.getContext("2d"), t = this.filterCanvas.getContext("2d");
+    !e || !t || (t.filter = "blur(0.5px)", t.clearRect(0, 0, this.filterCanvas.width, this.filterCanvas.height), t.drawImage(this.glCanvas, 0, 0, this.filterCanvas.width, this.filterCanvas.height), e.clearRect(0, 0, this.maskCanvas.width, this.maskCanvas.height), e.drawImage(this.filterCanvas, 0, 0, this.maskCanvas.width, this.maskCanvas.height));
+  }
+  /**
+   * CPU-fallback inverted-alpha ImageData build (only when the GPU path is off).
+   * The single-channel mask is expanded to RGBA with the person→transparent,
+   * background→opaque convention (green carries the signal for the alphaMap).
+   */
+  readMaskToImageData(e) {
+    const t = e.getAsUint8Array(), { width: n, height: r } = e;
+    if (!t || n <= 0 || r <= 0) return null;
+    (!this.maskImageData || this.maskImageData.width !== n || this.maskImageData.height !== r) && (this.maskImageData = new ImageData(n, r));
+    const c = this.maskImageData.data;
+    for (let d = 0; d < t.length; d += 1) {
+      const m = t[d] === 255 ? 0 : 255;
+      c[d * 4] = 255, c[d * 4 + 1] = m, c[d * 4 + 2] = 255, c[d * 4 + 3] = m;
+    }
+    return this.maskImageData;
+  }
+  /**
+   * CPU-fallback blit: put the inverted-alpha mask ImageData into maskCanvas
+   * with a soft-edge blur, cover-fitted to the render target. Only used when the
+   * GPU path is off; the GPU path blits the GL canvas directly (blitGlToMask).
+   */
+  blitImageDataToMask(e) {
+    if (!this.maskCanvas || !this.filterCanvas) return;
+    const t = this.maskCanvas.getContext("2d"), n = this.filterCanvas.getContext("2d");
+    if (!t || !n) return;
+    const r = this.getStagingCanvas(e.width, e.height), c = r.getContext("2d");
+    c && (c.putImageData(e, 0, 0), n.filter = "blur(0.5px)", n.clearRect(0, 0, this.filterCanvas.width, this.filterCanvas.height), n.drawImage(r, 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));
+  }
+  getStagingCanvas(e, t) {
+    return this.stagingCanvas || (this.stagingCanvas = document.createElement("canvas")), this.stagingCanvas.width !== e && (this.stagingCanvas.width = e), this.stagingCanvas.height !== t && (this.stagingCanvas.height = t), this.stagingCanvas;
+  }
+  resume() {
+    this.paused && (super.resume(), this.processSegmentation());
+  }
+  dispose() {
+    if (super.dispose(), this.isProcessing = !1, this.latestMask) {
+      try {
+        this.latestMask.close();
+      } catch {
+      }
+      this.latestMask = null;
+    }
+    if (this.rawCache = null, this.segmenter) {
+      try {
+        this.segmenter.close();
+      } catch {
+      }
+      this.segmenter = null;
+    }
+    this.drawingUtils = void 0, this.glCanvas = void 0, this.maskImageData = void 0, this.segmentationMaskTexture && (this.segmentationMaskTexture.dispose(), this.segmentationMaskTexture = void 0), this.sourceCanvas = void 0, this.inputSource = void 0, this.inputSourceSize = void 0, this.processCanvas = void 0, this.filterCanvas = void 0, this.stagingCanvas = void 0, this.maskCanvas = null;
+  }
+  async initialize(e) {
+    this.quality = (e == null ? void 0 : e.quality) ?? "low";
+    const t = await U.forVisionTasks(
+      new URL("/assets/xr/wasm", x.assetStorageEndpoint).toString()
+    ), n = await z(
+      new URL("/assets/xr/models/segmentation.tflite", x.assetStorageEndpoint).toString()
+    );
+    this.glCanvas = new OffscreenCanvas(1, 1);
+    const r = this.glCanvas.getContext("webgl2", {
+      preserveDrawingBuffer: !0
+    });
+    this.segmenter = await Re.createFromOptions(t, {
+      baseOptions: {
+        modelAssetBuffer: n,
+        delegate: "GPU"
+      },
+      ...r ? { canvas: this.glCanvas } : {},
+      outputCategoryMask: !0,
+      outputConfidenceMasks: !1,
+      runningMode: "VIDEO"
+    }), r ? (this.drawingUtils = new Fe(r), this.useGpuMaskPath = !0) : this.useGpuMaskPath = !1;
+  }
+  async run({
+    sourceCanvas: e,
+    renderWidth: t,
+    renderHeight: n,
+    targetFps: r
+  }) {
+    if (!e)
+      return;
+    this.setTargetFps(r ?? Ge), this.isProcessing = !1, this.rafId !== null && (cancelAnimationFrame(this.rafId), this.rafId = null);
+    const c = this.getQualityScaleFactor();
+    this.sourceCanvas = e, this.processCanvas = document.createElement("canvas"), this.processCanvas.width = e.width * c, this.processCanvas.height = e.height * c, this.glCanvas && (this.glCanvas.width = this.processCanvas.width, this.glCanvas.height = this.processCanvas.height), this.maskImageData = void 0, this.maskCanvas = document.createElement("canvas"), this.maskCanvas.width = t, this.maskCanvas.height = n, this.filterCanvas = document.createElement("canvas"), this.filterCanvas.width = t, this.filterCanvas.height = n, this.segmentationMaskTexture = new se(this.maskCanvas), this.isMaskSetup = !1, this.rawCache = null, this.isProcessing = !0, this.lastInferenceMs = 0, this.rafId = requestAnimationFrame(this.processSegmentation.bind(this));
+  }
+  /**
+   * Lazily read the single-channel mask back to a Uint8Array. Only invoked when
+   * a consumer calls getRawSegmentationData(); the default texture path never
+   * touches it, so apps that only use <VideoBackground> pay no extra readback.
+   */
+  getRawSegmentationData() {
+    if (this.rawCache) return this.rawCache;
+    if (!this.latestMask) return null;
+    const e = this.latestMask.getAsUint8Array();
+    return this.rawCache = {
+      maskData: e,
+      width: this.latestMask.width,
+      height: this.latestMask.height
+    }, this.rawCache;
+  }
+  getModelNode() {
+    const e = this;
+    return {
+      get backgroundSegmentationMask() {
+        return e.segmentationMaskTexture;
+      },
+      getMaskCanvas: () => e.maskCanvas,
+      getRawSegmentationData: () => e.getRawSegmentationData(),
+      setInputSource: (t) => e.setInputSource(t ?? void 0)
+    };
+  }
+  async getPerformanceData() {
+    return {
+      name: this.constructor.name,
+      processingTime: this.processingTime
+    };
+  }
+}
+const Z = {
+  [_.BACKGROUND_SEGMENTATION]: Ye,
+  [_.HAND_TRACKER]: We,
+  [_.GESTURE_TRACKER]: qe,
+  [_.FACE_TRACKER]: Le,
+  [_.BODY_TRACKER]: Oe
+}, Qe = async (i) => {
+  const s = document.createElement("video");
+  s.srcObject = i, s.muted = !0, s.playsInline = !0, s.autoplay = !0, await new Promise((t) => {
+    s.onloadedmetadata = () => {
+      s.play(), t();
+    };
+  });
+  const e = s;
+  return await new Promise((t) => {
+    const n = setTimeout(t, 150), r = () => {
+      clearTimeout(n), t();
+    };
+    typeof e.requestVideoFrameCallback == "function" ? e.requestVideoFrameCallback(r) : requestAnimationFrame(() => requestAnimationFrame(() => r()));
+  }), s;
+}, J = (i) => {
+  const s = new se(i);
+  return s.colorSpace = xe, s.format = te, s.minFilter = B, s.magFilter = B, s.generateMipmaps = !1, s.needsUpdate = !0, s;
+}, je = (i, s) => {
+  const e = i.videoWidth, t = i.videoHeight;
+  e > 0 && t > 0 && (s.width !== e && (s.width = e), s.height !== t && (s.height = t));
+  const n = s.getContext("2d", {
+    colorSpace: "srgb"
+  });
+  n.save(), n.scale(-1, 1), n.drawImage(i, -s.width, 0, s.width, s.height), n.restore();
+}, Ze = (i, s, e = 1) => {
+  const t = s.getContext("2d", {
+    colorSpace: "srgb"
+  }), n = s.width / s.height, r = i.width / i.height;
+  let c, d;
+  r > n ? (d = s.height, c = i.width * (s.height / i.height)) : (c = s.width, d = i.height * (s.width / i.width));
+  const m = Number.isFinite(e) && e > 0 ? e : 1;
+  c *= m, d *= m;
+  const u = (s.width - c) / 2, g = (s.height - d) / 2;
+  t.setTransform(1, 0, 0, 1, 0, 0), t.clearRect(0, 0, s.width, s.height), t.drawImage(
+    i,
+    0,
+    0,
+    i.width,
+    i.height,
+    u,
+    g,
+    c,
+    d
+  );
+}, Je = (i, s, e) => {
+  const t = /* @__PURE__ */ new Map();
+  return { acquire: async (g, f, w) => {
+    let p = t.get(g);
+    if (p)
+      return p.refs.add(f), p.activeRefs.add(f), p.initPromise;
+    const k = s[g];
+    if (!k)
+      throw new Error(`Invalid model: ${g}`);
+    const C = new k(), R = /* @__PURE__ */ new Set([f]), E = /* @__PURE__ */ new Set([f]), b = (async () => {
+      await C.initialize(w), e && await e(g, C);
+      const A = t.get(g);
+      return A && A.refs.size > 0 && i.setPipeline((N) => N.set(g, C)), C;
+    })();
+    return p = { model: C, refs: R, activeRefs: E, initPromise: b, options: w }, t.set(g, p), b.catch(() => {
+      t.get(g) === p && (t.delete(g), i.setPipeline((N) => N.delete(g)));
+    }), b;
+  }, release: (g, f) => {
+    var k;
+    const w = t.get(g);
+    if (!w || (w.refs.delete(f), w.activeRefs.delete(f) && w.refs.size > 0 && w.activeRefs.size === 0 && w.model.pause(), w.refs.size > 0)) return;
+    t.delete(g);
+    const p = w.model;
+    try {
+      (k = p.dispose) == null || k.call(p);
+    } catch (C) {
+      console.warn(`[xr-sdk registry] dispose threw for ${g}`, C);
+    }
+    i.setPipeline((C) => C.delete(g));
+  }, setActive: (g, f, w) => {
+    const p = t.get(g);
+    if (!p || !p.refs.has(f)) return;
+    const k = p.activeRefs.size > 0;
+    w ? p.activeRefs.add(f) : p.activeRefs.delete(f);
+    const C = p.activeRefs.size > 0;
+    k !== C && (C ? p.model.resume() : p.model.pause());
+  }, get: (g) => {
+    var f;
+    return (f = t.get(g)) == null ? void 0 : f.model;
+  }, getOptions: (g) => {
+    var f;
+    return (f = t.get(g)) == null ? void 0 : f.options;
+  }, releaseAll: () => {
+    var g;
+    for (const f of Array.from(t.keys())) {
+      const w = t.get(f);
+      if (!w) continue;
+      w.refs.clear(), t.delete(f);
+      const p = w.model;
+      try {
+        (g = p.dispose) == null || g.call(p);
+      } catch (k) {
+        console.warn(`[xr-sdk registry] dispose threw for ${f}`, k);
+      }
+    }
+    i.setPipeline((f) => f.clear());
+  } };
+}, et = {
+  lifecycle: "idle",
+  ready: !1,
+  error: void 0,
+  cameraTexture: void 0,
+  renderWidth: 0,
+  renderHeight: 0,
+  source: void 0,
+  sourceKind: void 0,
+  pipeline: /* @__PURE__ */ new Map()
+}, tt = () => {
+  let i = { ...et, pipeline: /* @__PURE__ */ new Map() };
+  const s = /* @__PURE__ */ new Set(), e = () => {
+    s.forEach((t) => t());
+  };
+  return {
+    getSnapshot: () => i,
+    set: (t) => {
+      let n = !1;
+      for (const r of Object.keys(t))
+        if (t[r] !== i[r]) {
+          n = !0;
+          break;
+        }
+      n && (i = { ...i, ...t }, e());
+    },
+    setPipeline: (t) => {
+      const n = new Map(i.pipeline);
+      return t(n), i = { ...i, pipeline: n }, e(), n;
+    },
+    subscribe: (t) => (s.add(t), () => {
+      s.delete(t);
+    })
+  };
+}, st = ({
+  renderHeight: i,
+  renderWidth: s,
+  videoHeight: e,
+  videoWidth: t
+}) => ({
+  height: i || e,
+  width: s || t
+}), it = (i) => {
+  const s = new Ae({ verbose: !0 }), e = tt();
+  let t = i;
+  const n = (a) => {
+    var l;
+    const o = (l = P.getOptions(a)) == null ? void 0 : l.targetFps;
+    return typeof o == "number" ? o : t == null ? void 0 : t.targetFps;
+  };
+  let r, c, d, m, u, g, f, w, p, k, C = !1, R = !1;
+  const E = /* @__PURE__ */ new Set(), b = /* @__PURE__ */ new Set(), A = async (a, o) => {
+    if (!E.has(a) && e.getSnapshot().lifecycle === "running" && u) {
+      E.add(a);
+      try {
+        await o.run({
+          sourceCanvas: u,
+          renderWidth: e.getSnapshot().renderWidth,
+          renderHeight: e.getSnapshot().renderHeight,
+          getSource: () => e.getSnapshot().sourceKind,
+          targetFps: n(a)
+        }), R && (await new Promise((l) => requestAnimationFrame(() => l())), await new Promise((l) => requestAnimationFrame(() => l())), o.pause());
+      } catch (l) {
+        throw E.delete(a), l;
+      }
+    }
+  }, P = Je(e, Z, (a, o) => A(a, o));
+  e.subscribe(() => {
+    if (e.getSnapshot().lifecycle !== "running") return;
+    const a = e.getSnapshot().pipeline;
+    for (const [o, l] of a.entries())
+      E.has(o) || A(o, l);
+  });
+  const O = () => {
+    if (k !== void 0 && (cancelAnimationFrame(k), k = void 0), c) {
+      try {
+        c.pause();
+      } catch {
+      }
+      try {
+        c.srcObject = null;
+      } catch {
+      }
+      c = void 0;
+    }
+    if (d) {
+      try {
+        d.getTracks().forEach((a) => a.stop());
+      } catch {
+      }
+      d = void 0;
+    }
+  }, X = () => {
+    if (C || !c || !m || !u) return;
+    const a = window.__xr_debugger_metrics;
+    if (a != null && a.trackCameraFrame && a.trackCameraFrame(), (e.getSnapshot().sourceKind ?? "webcam") === "webcam")
+      je(c, m);
+    else {
+      const v = m.getContext("2d");
+      if (!v) return;
+      const S = c.videoWidth, M = c.videoHeight;
+      m.width !== S && (m.width = S), m.height !== M && (m.height = M), v.setTransform(1, 0, 0, 1, 0, 0), v.clearRect(0, 0, S, M), v.drawImage(c, 0, 0, S, M);
+    }
+    Ze(m, u, (t == null ? void 0 : t.cameraZoom) ?? 1.2);
+    const l = e.getSnapshot().cameraTexture;
+    l && (l.needsUpdate = !0);
+  }, $ = () => {
+    if (!c || !m || !u) return;
+    if (R) {
+      X();
+      return;
+    }
+    const a = () => {
+      k = requestAnimationFrame(a), X();
+    };
+    k = requestAnimationFrame(a);
+  }, ae = async (a) => {
+    if (a.source === y.WEBCAM)
+      try {
+        const o = t != null && t.camRes && t.camRes > 0 ? t.camRes : 960;
+        return await navigator.mediaDevices.getUserMedia({
+          video: {
+            facingMode: "user",
+            frameRate: { min: 24, ideal: 30, max: 60 },
+            width: { ideal: o }
+          }
+        });
+      } catch (o) {
+        const l = o instanceof DOMException ? o.name : "", v = l === "NotReadableError" || l === "TrackStartError" ? "Camera is already in use by another app or browser tab. Close it and refresh." : l === "NotFoundError" || l === "DevicesNotFoundError" ? "No camera was found on this device." : l === "NotAllowedError" || l === "PermissionDeniedError" ? "Camera access was blocked. Allow camera permissions in your browser, then refresh." : "Unable to access camera. Allow camera permissions in your browser, then refresh.";
+        throw e.set({ error: { error: "PermissionError", message: v } }), new F(o instanceof Error ? o.message : "getUserMedia failed");
+      }
+    return a.stream;
+  }, H = async (a) => {
+    const o = await ae(a);
+    d = o;
+    const l = await Qe(o);
+    c = l, m = new OffscreenCanvas(l.videoWidth, l.videoHeight);
+    const { renderWidth: v, renderHeight: S } = e.getSnapshot(), M = st({
+      renderWidth: v,
+      renderHeight: S,
+      videoWidth: l.videoWidth,
+      videoHeight: l.videoHeight
+    });
+    if (u)
+      (u.width !== M.width || u.height !== M.height) && (u.width = M.width, u.height = M.height);
+    else {
+      u = new OffscreenCanvas(M.width, M.height);
+      const me = J(u);
+      e.set({ cameraTexture: me });
+    }
+    const j = a.source === y.STREAM ? a.static === !0 : !1;
+    R = j, r = a.source === y.WEBCAM ? { source: y.WEBCAM, sourceKind: "webcam" } : {
+      source: y.STREAM,
+      stream: a.stream,
+      static: j,
+      sourceKind: a.sourceKind ?? "webcam"
+    }, e.set({
+      source: a.source,
+      sourceKind: r.sourceKind,
+      error: void 0
+    });
+  }, q = async (a) => {
+    const o = a.sourceKind ?? "webcam";
+    u = a.canvas;
+    const l = J(u);
+    e.set({
+      cameraTexture: l,
+      source: y.CANVAS,
+      sourceKind: o,
+      renderWidth: u.width,
+      renderHeight: u.height,
+      error: void 0
+    }), r = {
+      source: y.CANVAS,
+      canvas: a.canvas,
+      sourceKind: o
+    };
+  }, ne = (a, o) => !o || a.source !== o.source ? !1 : a.source === y.STREAM && o.source === y.STREAM ? a.stream === o.stream && (a.sourceKind ?? "webcam") === o.sourceKind : !0, re = async () => {
+    if (!u) return;
+    const a = e.getSnapshot().pipeline;
+    for (const [, o] of a.entries())
+      o.resume();
+    await new Promise((o) => requestAnimationFrame(() => o())), await new Promise((o) => requestAnimationFrame(() => o()));
+    for (const [, o] of a.entries())
+      o.pause();
+  }, oe = (a, o) => !o || o.source !== y.CANVAS ? !1 : a.canvas === o.canvas && (a.sourceKind ?? "webcam") === o.sourceKind, ce = async (a) => {
+    const o = a.source;
+    if (o !== y.WEBCAM && o !== y.STREAM)
+      throw new F(`Invalid media source: ${String(o)}`);
+    if (ne(a, r)) {
+      s.log("Media source unchanged, skipping rebind.");
+      return;
+    }
+    const { lifecycle: l } = e.getSnapshot();
+    if (l === "idle" || l === "stopped") {
+      await H(a), e.set({ lifecycle: "media-bound" }), s.log("Media source set to:", a.source);
+      return;
+    }
+    if (l === "media-bound") {
+      O(), await H(a), s.log("Media source rebound to:", a.source);
+      return;
+    }
+    if (C = !0, await new Promise((v) => requestAnimationFrame(() => v())), O(), await H(a), C = !1, $(), R)
+      await re();
+    else {
+      const v = e.getSnapshot().pipeline;
+      for (const [, S] of v.entries()) S.resume();
+    }
+    s.log("Media source swapped to:", a.source);
+  }, he = async (a) => {
+    if (oe(a, r)) {
+      s.log("Frame source unchanged, skipping rebind.");
+      return;
+    }
+    const { lifecycle: o } = e.getSnapshot();
+    if (o === "idle" || o === "stopped") {
+      await q(a), e.set({ lifecycle: "media-bound" }), s.log("Frame source set to canvas.");
+      return;
+    }
+    if (o === "media-bound") {
+      O(), await q(a), s.log("Frame source rebound to canvas.");
+      return;
+    }
+    C = !0, await new Promise((l) => requestAnimationFrame(() => l())), O(), await q(a), C = !1, s.log("Frame source swapped to canvas.");
+  }, de = async () => {
+    const { lifecycle: a } = e.getSnapshot();
+    if (a === "running") return;
+    if (a === "idle")
+      throw new F("session.start() called before setMediaSource — call setMediaSource first");
+    if (!u)
+      throw new F("session.start(): media source not bound");
+    const o = (r == null ? void 0 : r.source) === y.CANVAS;
+    if (!o && (!c || !m))
+      throw a === "stopped" ? new F(
+        "session.start() called from stopped state without a media source — call setMediaSource first"
+      ) : new F("session.start(): media source not bound");
+    o || $(), e.set({ lifecycle: "running" }), await new Promise((v) => requestAnimationFrame(() => v()));
+    const l = e.getSnapshot().pipeline;
+    for (const [v, S] of l.entries())
+      await A(v, S);
+    e.set({ ready: !0 }), s.log("XR session started.");
+  }, Y = async () => {
+    const { lifecycle: a } = e.getSnapshot();
+    a === "stopped" || a === "idle" || (O(), e.set({ lifecycle: "stopped", ready: !1 }), s.log("XR session stopped."));
+  }, ue = async () => {
+    await Y(), P.releaseAll(), b.clear(), E.clear(), r = void 0, u = void 0, m = void 0, R = !1, e.set({
+      lifecycle: "idle",
+      cameraTexture: void 0,
+      source: void 0
+    }), s.log("XR session reset.");
+  }, le = async (a) => {
+    const o = "legacy:registerXRPipeline", l = [];
+    await Promise.all(
+      a.map(async (v) => {
+        const { model: S } = v;
+        if (!Z[S])
+          throw new F(`Invalid model: ${S}`);
+        b.has(S) || l.push(S);
+        const M = "options" in v ? v.options : void 0;
+        await P.acquire(S, o, M);
+      })
+    ), l.length > 0 && (l.forEach((v) => b.add(v)), s.log("XR pipeline registered."));
+  }, ge = (a) => {
+    const o = P.get(a);
+    if (!o)
+      throw new F(`Model ${a} is not registered in the pipeline`);
+    return o.getModelNode();
+  }, Q = async (a, o) => {
+    a <= 0 || o <= 0 || (e.set({ renderWidth: a, renderHeight: o }), u && (u.width !== a || u.height !== o) && (u.width = a, u.height = o), s.log(`Source canvas set. Render size: ${a}x${o}`));
+  };
+  return {
+    store: e,
+    registry: P,
+    setMediaSource: ce,
+    start: de,
+    stop: Y,
+    reset: ue,
+    setFrameSource: he,
+    registerXRPipeline: le,
+    getModelNode: ge,
+    captureFrame: () => {
+      if (!g)
+        throw new F(
+          "session.captureFrame() called before the XRScene render target was bound — make sure <XRScene> is mounted"
+        );
+      if (!f || !w || !p)
+        throw new F(
+          "session.captureFrame() called before the R3F state was bound — make sure <XRScene> is mounted"
+        );
+      return f.render(w, p), g.toDataURL("image/png");
+    },
+    _setRenderTarget: async (a) => {
+      var S;
+      g = a;
+      const o = (S = a.getBoundingClientRect) == null ? void 0 : S.call(a), l = o && o.width > 0 ? Math.round(o.width) : a.clientWidth, v = o && o.height > 0 ? Math.round(o.height) : a.clientHeight;
+      await Q(l, v);
+    },
+    _setRenderSize: Q,
+    _setR3FState: (a) => {
+      f = a.renderer, w = a.scene, p = a.camera;
+    },
+    _getVideoElement: () => c,
+    _setPerf: (a) => {
+      if (t = a, e.getSnapshot().lifecycle !== "running" || !u) return;
+      const o = e.getSnapshot().pipeline;
+      for (const [l, v] of o.entries())
+        v.run({
+          sourceCanvas: u,
+          renderWidth: e.getSnapshot().renderWidth,
+          renderHeight: e.getSnapshot().renderHeight,
+          getSource: () => e.getSnapshot().sourceKind,
+          targetFps: n(l)
+        });
+    }
+  };
+}, at = (i) => {
+  const s = ee(() => it(i), []), e = JSON.stringify(i ?? {});
+  return ve(() => {
+    s._setPerf(i);
+  }, [s, e]), s;
+}, ie = Ce(void 0), wt = () => {
+  const i = Se(ie);
+  if (!i)
+    throw new F(
+      "XR context can only be used inside XRProvider, did you forget to wrap your app in <XRProvider>?"
+    );
+  return i;
+}, vt = ({ children: i, perf: s }) => {
+  const e = at(s), t = ee(() => ({ session: e }), [e]);
+  return /* @__PURE__ */ we(ie.Provider, { value: t, children: i });
+};
+export {
+  ft as R,
+  _ as X,
+  vt as a,
+  y as b,
+  V as c,
+  pt as d,
+  Ie as f,
+  x as l,
+  wt as u
+};