iwer 1.0.4 → 1.1.0

package/build/iwer.js

@@ -140,6 +140,32 @@
     out[15] = a[15];
     return out;
   }
+  /**
+   * Set a mat4 to the identity matrix
+   *
+   * @param {mat4} out the receiving matrix
+   * @returns {mat4} out
+   */
+
+  function identity(out) {
+    out[0] = 1;
+    out[1] = 0;
+    out[2] = 0;
+    out[3] = 0;
+    out[4] = 0;
+    out[5] = 1;
+    out[6] = 0;
+    out[7] = 0;
+    out[8] = 0;
+    out[9] = 0;
+    out[10] = 1;
+    out[11] = 0;
+    out[12] = 0;
+    out[13] = 0;
+    out[14] = 0;
+    out[15] = 1;
+    return out;
+  }
   /**
    * Inverts a mat4
    *
@@ -295,6 +321,56 @@
     out[15] = 1;
     return out;
   }
+  /**
+   * Creates a matrix from a given angle around a given axis
+   * This is equivalent to (but much faster than):
+   *
+   *     mat4.identity(dest);
+   *     mat4.rotate(dest, dest, rad, axis);
+   *
+   * @param {mat4} out mat4 receiving operation result
+   * @param {Number} rad the angle to rotate the matrix by
+   * @param {ReadonlyVec3} axis the axis to rotate around
+   * @returns {mat4} out
+   */
+
+  function fromRotation(out, rad, axis) {
+    var x = axis[0],
+        y = axis[1],
+        z = axis[2];
+    var len = Math.hypot(x, y, z);
+    var s, c, t;
+
+    if (len < EPSILON) {
+      return null;
+    }
+
+    len = 1 / len;
+    x *= len;
+    y *= len;
+    z *= len;
+    s = Math.sin(rad);
+    c = Math.cos(rad);
+    t = 1 - c; // Perform rotation-specific matrix multiplication
+
+    out[0] = x * x * t + c;
+    out[1] = y * x * t + z * s;
+    out[2] = z * x * t - y * s;
+    out[3] = 0;
+    out[4] = x * y * t - z * s;
+    out[5] = y * y * t + c;
+    out[6] = z * y * t + x * s;
+    out[7] = 0;
+    out[8] = x * z * t + y * s;
+    out[9] = y * z * t - x * s;
+    out[10] = z * z * t + c;
+    out[11] = 0;
+    out[12] = 0;
+    out[13] = 0;
+    out[14] = 0;
+    out[15] = 1;
+    return out;
+  }
   /**
    * Creates a matrix from a quaternion rotation and vector translation
    * This is equivalent to (but much faster than):
@@ -917,6 +993,26 @@
     out[3] = w * len;
     return out;
   }
+  /**
+   * Transforms the vec4 with a mat4.
+   *
+   * @param {vec4} out the receiving vector
+   * @param {ReadonlyVec4} a the vector to transform
+   * @param {ReadonlyMat4} m matrix to transform with
+   * @returns {vec4} out
+   */
+
+  function transformMat4(out, a, m) {
+    var x = a[0],
+        y = a[1],
+        z = a[2],
+        w = a[3];
+    out[0] = m[0] * x + m[4] * y + m[8] * z + m[12] * w;
+    out[1] = m[1] * x + m[5] * y + m[9] * z + m[13] * w;
+    out[2] = m[2] * x + m[6] * y + m[10] * z + m[14] * w;
+    out[3] = m[3] * x + m[7] * y + m[11] * z + m[15] * w;
+    return out;
+  }
   /**
    * Perform some operation over an array of vec4s.
    *
@@ -1287,11 +1383,44 @@
    * This source code is licensed under the MIT license found in the
    * LICENSE file in the root directory of this source tree.
    */
-  const PRIVATE$l = Symbol('@immersive-web-emulation-runtime/xr-space');
+  const P_ACTION_PLAYER = Symbol('@iwer/action-player');
+  const P_ACTION_RECORDER = Symbol('@iwer/action-recorder');
+  const P_ANCHOR = Symbol('@iwer/xr-anchor');
+  const P_CONTROLLER = Symbol('@iwer/xr-controller');
+  const P_DEVICE = Symbol('@iwer/xr-device');
+  const P_HAND_INPUT = Symbol('@iwer/xr-hand-input');
+  const P_TRACKED_INPUT = Symbol('@iwer/xr-tracked-input');
+  const P_FRAME = Symbol('@iwer/xr-frame');
+  const P_GAMEPAD = Symbol('@iwer/gamepad');
+  const P_SYSTEM = Symbol('@iwer/xr-system');
+  const P_INPUT_SOURCE = Symbol('@iwer/xr-input-source');
+  const P_WEBGL_LAYER = Symbol('@iwer/xr-webgl-layer');
+  const P_MESH = Symbol('@iwer/xr-mesh');
+  const P_PLANE = Symbol('@iwer/xr-plane');
+  const P_JOINT_POSE = Symbol('@iwer/xr-joint-pose');
+  const P_POSE = Symbol('@iwer/xr-pose');
+  const P_VIEWER_POSE = Symbol('@iwer/xr-viewer-pose');
+  const P_RIGID_TRANSFORM = Symbol('@iwer/xr-rigid-transform');
+  const P_RENDER_STATE = Symbol('@iwer/xr-render-state');
+  const P_SESSION = Symbol('@iwer/xr-session');
+  const P_JOINT_SPACE = Symbol('@iwer/xr-joint-space');
+  const P_REF_SPACE = Symbol('@iwer/xr-reference-space');
+  const P_SPACE = Symbol('@iwer/xr-space');
+  const P_VIEW = Symbol('@iwer/xr-view');
+  const P_VIEWPORT = Symbol('@iwer/xr-viewport');
+  const P_RAY = Symbol('@iwer/xr-ray');
+  const P_HIT_TEST = Symbol('@iwer/xr-hit-test');
+
+  /**
+   * Copyright (c) Meta Platforms, Inc. and affiliates.
+   *
+   * This source code is licensed under the MIT license found in the
+   * LICENSE file in the root directory of this source tree.
+   */
   class XRSpace extends EventTarget {
       constructor(parentSpace, offsetMatrix) {
           super();
-          this[PRIVATE$l] = {
+          this[P_SPACE] = {
               parentSpace,
               offsetMatrix: offsetMatrix ? clone(offsetMatrix) : create$3(),
               emulated: true,
@@ -1306,27 +1435,27 @@
   class XRSpaceUtils {
       // Update the position component of the offsetMatrix of a given XRSpace
       static updateOffsetPosition(space, position) {
-          const offsetMatrix = space[PRIVATE$l].offsetMatrix;
+          const offsetMatrix = space[P_SPACE].offsetMatrix;
           fromTranslation(offsetMatrix, position);
       }
       // Update the rotation component of the offsetMatrix of a given XRSpace using a quaternion
       static updateOffsetQuaternion(space, quaternion) {
-          const offsetMatrix = space[PRIVATE$l].offsetMatrix;
+          const offsetMatrix = space[P_SPACE].offsetMatrix;
           const translation = create$2();
           getTranslation(translation, offsetMatrix);
           fromRotationTranslation(offsetMatrix, quaternion, translation);
       }
       // Update the offsetMatrix of a given XRSpace directly
       static updateOffsetMatrix(space, matrix) {
-          const offsetMatrix = space[PRIVATE$l].offsetMatrix;
+          const offsetMatrix = space[P_SPACE].offsetMatrix;
           copy$3(offsetMatrix, matrix);
       }
       // Calculate the global offset matrix for a given XRSpace
       static calculateGlobalOffsetMatrix(space, globalOffset = create$3()) {
-          const parentOffset = space[PRIVATE$l].parentSpace
-              ? XRSpaceUtils.calculateGlobalOffsetMatrix(space[PRIVATE$l].parentSpace)
+          const parentOffset = space[P_SPACE].parentSpace
+              ? XRSpaceUtils.calculateGlobalOffsetMatrix(space[P_SPACE].parentSpace)
               : create$3(); // Identity matrix for GlobalSpace
-          multiply$1(globalOffset, parentOffset, space[PRIVATE$l].offsetMatrix);
+          multiply$1(globalOffset, parentOffset, space[P_SPACE].offsetMatrix);
           return globalOffset;
       }
   }
@@ -1470,7 +1599,6 @@
    * This source code is licensed under the MIT license found in the
    * LICENSE file in the root directory of this source tree.
    */
-  const PRIVATE$k = Symbol('@immersive-web-emulation-runtime/gamepad');
   var GamepadMappingType;
   (function (GamepadMappingType) {
       GamepadMappingType["None"] = "";
@@ -1479,7 +1607,7 @@
   })(GamepadMappingType || (GamepadMappingType = {}));
   class GamepadButton {
       constructor(type, eventTrigger) {
-          this[PRIVATE$k] = {
+          this[P_GAMEPAD] = {
               type,
               eventTrigger,
               pressed: false,
@@ -1490,23 +1618,23 @@
           };
       }
       get pressed() {
-          if (this[PRIVATE$k].type === 'manual') {
-              return this[PRIVATE$k].pressed;
+          if (this[P_GAMEPAD].type === 'manual') {
+              return this[P_GAMEPAD].pressed;
           }
           else {
-              return this[PRIVATE$k].value > 0;
+              return this[P_GAMEPAD].value > 0;
           }
       }
       get touched() {
-          if (this[PRIVATE$k].type === 'manual') {
-              return this[PRIVATE$k].touched;
+          if (this[P_GAMEPAD].type === 'manual') {
+              return this[P_GAMEPAD].touched;
           }
           else {
-              return this[PRIVATE$k].touched || this.pressed;
+              return this[P_GAMEPAD].touched || this.pressed;
           }
       }
       get value() {
-          return this[PRIVATE$k].value;
+          return this[P_GAMEPAD].value;
       }
   }
   class EmptyGamepadButton {
@@ -1518,7 +1646,7 @@
   }
   class Gamepad {
       constructor(gamepadConfig, id = '', index = -1) {
-          this[PRIVATE$k] = {
+          this[P_GAMEPAD] = {
               id,
               index,
               connected: false,
@@ -1533,43 +1661,43 @@
           gamepadConfig.buttons.forEach((buttonConfig) => {
               var _a;
               if (buttonConfig === null) {
-                  this[PRIVATE$k].buttonsSequence.push(null);
+                  this[P_GAMEPAD].buttonsSequence.push(null);
               }
               else {
-                  this[PRIVATE$k].buttonsSequence.push(buttonConfig.id);
-                  this[PRIVATE$k].buttonsMap[buttonConfig.id] = new GamepadButton(buttonConfig.type, (_a = buttonConfig.eventTrigger) !== null && _a !== void 0 ? _a : null);
+                  this[P_GAMEPAD].buttonsSequence.push(buttonConfig.id);
+                  this[P_GAMEPAD].buttonsMap[buttonConfig.id] = new GamepadButton(buttonConfig.type, (_a = buttonConfig.eventTrigger) !== null && _a !== void 0 ? _a : null);
               }
           });
           gamepadConfig.axes.forEach((axisConfig) => {
               if (axisConfig === null) {
-                  this[PRIVATE$k].axesSequence.push(null);
+                  this[P_GAMEPAD].axesSequence.push(null);
               }
               else {
-                  this[PRIVATE$k].axesSequence.push(axisConfig.id + axisConfig.type);
-                  if (!this[PRIVATE$k].axesMap[axisConfig.id]) {
-                      this[PRIVATE$k].axesMap[axisConfig.id] = { x: 0, y: 0 };
+                  this[P_GAMEPAD].axesSequence.push(axisConfig.id + axisConfig.type);
+                  if (!this[P_GAMEPAD].axesMap[axisConfig.id]) {
+                      this[P_GAMEPAD].axesMap[axisConfig.id] = { x: 0, y: 0 };
                   }
               }
           });
       }
       get id() {
-          return this[PRIVATE$k].id;
+          return this[P_GAMEPAD].id;
       }
       get index() {
-          return this[PRIVATE$k].index;
+          return this[P_GAMEPAD].index;
       }
       get connected() {
-          return this[PRIVATE$k].connected;
+          return this[P_GAMEPAD].connected;
       }
       get timestamp() {
-          return this[PRIVATE$k].timestamp;
+          return this[P_GAMEPAD].timestamp;
       }
       get mapping() {
-          return this[PRIVATE$k].mapping;
+          return this[P_GAMEPAD].mapping;
       }
       get axes() {
           const axes = [];
-          this[PRIVATE$k].axesSequence.forEach((id) => {
+          this[P_GAMEPAD].axesSequence.forEach((id) => {
               if (id === null) {
                   axes.push(null);
               }
@@ -1579,17 +1707,17 @@
                   axes.push(
                   // if axis type is manual, then return the x value
                   axisType === 'y-axis'
-                      ? this[PRIVATE$k].axesMap[axisId].y
-                      : this[PRIVATE$k].axesMap[axisId].x);
+                      ? this[P_GAMEPAD].axesMap[axisId].y
+                      : this[P_GAMEPAD].axesMap[axisId].x);
               }
           });
           return axes;
       }
       get buttons() {
-          return this[PRIVATE$k].buttonsSequence.map((id) => id === null ? new EmptyGamepadButton() : this[PRIVATE$k].buttonsMap[id]);
+          return this[P_GAMEPAD].buttonsSequence.map((id) => id === null ? new EmptyGamepadButton() : this[P_GAMEPAD].buttonsMap[id]);
       }
       get hapticActuators() {
-          return this[PRIVATE$k].hapticActuators;
+          return this[P_GAMEPAD].hapticActuators;
       }
       get vibrationActuator() {
           return null;
@@ -1617,10 +1745,9 @@
   })(XRTargetRayMode || (XRTargetRayMode = {}));
   class XRInputSourceArray extends Array {
   }
-  const PRIVATE$j = Symbol('@immersive-web-emulation-runtime/xr-input-source');
   class XRInputSource {
       constructor(handedness, targetRayMode, profiles, targetRaySpace, gamepad, gripSpace, hand) {
-          this[PRIVATE$j] = {
+          this[P_INPUT_SOURCE] = {
               handedness,
               targetRayMode,
               targetRaySpace,
@@ -1631,25 +1758,25 @@
           };
       }
       get handedness() {
-          return this[PRIVATE$j].handedness;
+          return this[P_INPUT_SOURCE].handedness;
       }
       get targetRayMode() {
-          return this[PRIVATE$j].targetRayMode;
+          return this[P_INPUT_SOURCE].targetRayMode;
       }
       get targetRaySpace() {
-          return this[PRIVATE$j].targetRaySpace;
+          return this[P_INPUT_SOURCE].targetRaySpace;
       }
       get gripSpace() {
-          return this[PRIVATE$j].gripSpace;
+          return this[P_INPUT_SOURCE].gripSpace;
       }
       get profiles() {
-          return this[PRIVATE$j].profiles;
+          return this[P_INPUT_SOURCE].profiles;
       }
       get gamepad() {
-          return this[PRIVATE$j].gamepad;
+          return this[P_INPUT_SOURCE].gamepad;
       }
       get hand() {
-          return this[PRIVATE$j].hand;
+          return this[P_INPUT_SOURCE].hand;
       }
   }
 
@@ -1679,7 +1806,6 @@
    * This source code is licensed under the MIT license found in the
    * LICENSE file in the root directory of this source tree.
    */
-  const PRIVATE$i = Symbol('@immersive-web-emulation-runtime/xr-tracked-input');
   const DEFAULT_TRANSFORM = {
       [XRHandedness.Left]: {
           position: new Vector3(-0.25, 1.5, -0.4),
@@ -1696,7 +1822,7 @@
   };
   class XRTrackedInput {
       constructor(inputSource) {
-          this[PRIVATE$i] = {
+          this[P_TRACKED_INPUT] = {
               inputSource,
               position: DEFAULT_TRANSFORM[inputSource.handedness].position.clone(),
               quaternion: DEFAULT_TRANSFORM[inputSource.handedness].quaternion.clone(),
@@ -1706,59 +1832,59 @@
           };
       }
       get position() {
-          return this[PRIVATE$i].position;
+          return this[P_TRACKED_INPUT].position;
       }
       get quaternion() {
-          return this[PRIVATE$i].quaternion;
+          return this[P_TRACKED_INPUT].quaternion;
       }
       get inputSource() {
-          return this[PRIVATE$i].inputSource;
+          return this[P_TRACKED_INPUT].inputSource;
       }
       get connected() {
-          return this[PRIVATE$i].connected;
+          return this[P_TRACKED_INPUT].connected;
       }
       set connected(value) {
-          this[PRIVATE$i].connected = value;
-          this[PRIVATE$i].inputSource.gamepad[PRIVATE$k].connected = value;
+          this[P_TRACKED_INPUT].connected = value;
+          this[P_TRACKED_INPUT].inputSource.gamepad[P_GAMEPAD].connected = value;
       }
       onFrameStart(frame) {
-          const targetRaySpace = this[PRIVATE$i].inputSource.targetRaySpace;
-          fromRotationTranslation(targetRaySpace[PRIVATE$l].offsetMatrix, this[PRIVATE$i].quaternion.quat, this[PRIVATE$i].position.vec3);
+          const targetRaySpace = this[P_TRACKED_INPUT].inputSource.targetRaySpace;
+          fromRotationTranslation(targetRaySpace[P_SPACE].offsetMatrix, this[P_TRACKED_INPUT].quaternion.quat, this[P_TRACKED_INPUT].position.vec3);
           const session = frame.session;
-          this[PRIVATE$i].inputSource.gamepad.buttons.forEach((button) => {
+          this[P_TRACKED_INPUT].inputSource.gamepad.buttons.forEach((button) => {
               if (button instanceof GamepadButton) {
                   // apply pending values and record last frame values
-                  button[PRIVATE$k].lastFrameValue = button[PRIVATE$k].value;
-                  if (button[PRIVATE$k].pendingValue != null) {
-                      button[PRIVATE$k].value = button[PRIVATE$k].pendingValue;
-                      button[PRIVATE$k].pendingValue = null;
+                  button[P_GAMEPAD].lastFrameValue = button[P_GAMEPAD].value;
+                  if (button[P_GAMEPAD].pendingValue != null) {
+                      button[P_GAMEPAD].value = button[P_GAMEPAD].pendingValue;
+                      button[P_GAMEPAD].pendingValue = null;
                   }
                   // trigger input source events
-                  if (button[PRIVATE$k].eventTrigger != null) {
-                      if (button[PRIVATE$k].lastFrameValue === 0 &&
-                          button[PRIVATE$k].value > 0) {
-                          session.dispatchEvent(new XRInputSourceEvent(button[PRIVATE$k].eventTrigger, {
+                  if (button[P_GAMEPAD].eventTrigger != null) {
+                      if (button[P_GAMEPAD].lastFrameValue === 0 &&
+                          button[P_GAMEPAD].value > 0) {
+                          session.dispatchEvent(new XRInputSourceEvent(button[P_GAMEPAD].eventTrigger, {
                               frame,
-                              inputSource: this[PRIVATE$i].inputSource,
+                              inputSource: this[P_TRACKED_INPUT].inputSource,
                           }));
-                          session.dispatchEvent(new XRInputSourceEvent(button[PRIVATE$k].eventTrigger + 'start', {
+                          session.dispatchEvent(new XRInputSourceEvent(button[P_GAMEPAD].eventTrigger + 'start', {
                               frame,
-                              inputSource: this[PRIVATE$i].inputSource,
+                              inputSource: this[P_TRACKED_INPUT].inputSource,
                           }));
                       }
-                      else if (button[PRIVATE$k].lastFrameValue > 0 &&
-                          button[PRIVATE$k].value === 0) {
-                          session.dispatchEvent(new XRInputSourceEvent(button[PRIVATE$k].eventTrigger + 'end', {
+                      else if (button[P_GAMEPAD].lastFrameValue > 0 &&
+                          button[P_GAMEPAD].value === 0) {
+                          session.dispatchEvent(new XRInputSourceEvent(button[P_GAMEPAD].eventTrigger + 'end', {
                               frame,
-                              inputSource: this[PRIVATE$i].inputSource,
+                              inputSource: this[P_TRACKED_INPUT].inputSource,
                           }));
                       }
                   }
               }
           });
-          this[PRIVATE$i].inputSourceChanged =
-              this.connected !== this[PRIVATE$i].lastFrameConnected;
-          this[PRIVATE$i].lastFrameConnected = this.connected;
+          this[P_TRACKED_INPUT].inputSourceChanged =
+              this.connected !== this[P_TRACKED_INPUT].lastFrameConnected;
+          this[P_TRACKED_INPUT].lastFrameConnected = this.connected;
       }
   }
 
@@ -1768,7 +1894,6 @@
    * This source code is licensed under the MIT license found in the
    * LICENSE file in the root directory of this source tree.
    */
-  const PRIVATE$h = Symbol('@immersive-web-emulation-runtime/xr-controller');
   class XRController extends XRTrackedInput {
       constructor(controllerConfig, handedness, globalSpace) {
           if (!controllerConfig.layout[handedness]) {
@@ -1784,38 +1909,36 @@
           ];
           const inputSource = new XRInputSource(handedness, XRTargetRayMode.TrackedPointer, profiles, targetRaySpace, new Gamepad(controllerConfig.layout[handedness].gamepad), gripSpace);
           super(inputSource);
-          this[PRIVATE$h] = {
+          this[P_CONTROLLER] = {
               gamepadConfig: controllerConfig.layout[handedness].gamepad,
           };
       }
       get gamepadConfig() {
-          return this[PRIVATE$h].gamepadConfig;
+          return this[P_CONTROLLER].gamepadConfig;
       }
       updateButtonValue(id, value) {
           if (value > 1 || value < 0) {
               console.warn(`Out-of-range value ${value} provided for button ${id}.`);
               return;
           }
-          const gamepadButton = this[PRIVATE$i].inputSource.gamepad[PRIVATE$k]
-              .buttonsMap[id];
+          const gamepadButton = this[P_TRACKED_INPUT].inputSource.gamepad[P_GAMEPAD].buttonsMap[id];
           if (gamepadButton) {
-              if (gamepadButton[PRIVATE$k].type === 'binary' &&
+              if (gamepadButton[P_GAMEPAD].type === 'binary' &&
                   value != 1 &&
                   value != 0) {
                   console.warn(`Non-binary value ${value} provided for binary button ${id}.`);
                   return;
               }
-              gamepadButton[PRIVATE$k].pendingValue = value;
+              gamepadButton[P_GAMEPAD].pendingValue = value;
           }
           else {
               console.warn(`Current controller does not have button ${id}.`);
           }
       }
       updateButtonTouch(id, touched) {
-          const gamepadButton = this[PRIVATE$i].inputSource.gamepad[PRIVATE$k]
-              .buttonsMap[id];
+          const gamepadButton = this[P_TRACKED_INPUT].inputSource.gamepad[P_GAMEPAD].buttonsMap[id];
           if (gamepadButton) {
-              gamepadButton[PRIVATE$k].touched = touched;
+              gamepadButton[P_GAMEPAD].touched = touched;
           }
           else {
               console.warn(`Current controller does not have button ${id}.`);
@@ -1826,8 +1949,7 @@
               console.warn(`Out-of-range value ${value} provided for ${id} axes.`);
               return;
           }
-          const axesById = this[PRIVATE$i].inputSource.gamepad[PRIVATE$k]
-              .axesMap[id];
+          const axesById = this[P_TRACKED_INPUT].inputSource.gamepad[P_GAMEPAD].axesMap[id];
           if (axesById) {
               if (type === 'x-axis') {
                   axesById.x = value;
@@ -1845,8 +1967,7 @@
               console.warn(`Out-of-range value x:${x}, y:${y} provided for ${id} axes.`);
               return;
           }
-          const axesById = this[PRIVATE$i].inputSource.gamepad[PRIVATE$k]
-              .axesMap[id];
+          const axesById = this[P_TRACKED_INPUT].inputSource.gamepad[P_GAMEPAD].axesMap[id];
           if (axesById) {
               axesById.x = x;
               axesById.y = y;
@@ -1863,42 +1984,42 @@
    * This source code is licensed under the MIT license found in the
    * LICENSE file in the root directory of this source tree.
    */
-  const PRIVATE$g = Symbol('@immersive-web-emulation-runtime/xr-view');
-  var XREye;
-  (function (XREye) {
-      XREye["None"] = "none";
-      XREye["Left"] = "left";
-      XREye["Right"] = "right";
-  })(XREye || (XREye = {}));
-  class XRView {
-      constructor(eye, projectionMatrix, transform, session) {
-          this[PRIVATE$g] = {
-              eye,
-              projectionMatrix,
-              transform,
-              recommendedViewportScale: null,
-              requestedViewportScale: 1.0,
-              session,
+  class XRMesh {
+      constructor(nativeMesh, meshSpace, vertices, indices, semanticLabel) {
+          this[P_MESH] = {
+              nativeMesh,
+              frame: undefined,
+              meshSpace,
+              vertices,
+              indices,
+              lastChangedTime: performance.now(),
+              semanticLabel,
           };
       }
-      get eye() {
-          return this[PRIVATE$g].eye;
+      get meshSpace() {
+          return this[P_MESH].meshSpace;
       }
-      get projectionMatrix() {
-          return this[PRIVATE$g].projectionMatrix;
+      get vertices() {
+          return this[P_MESH].vertices;
       }
-      get transform() {
-          return this[PRIVATE$g].transform;
+      get indices() {
+          return this[P_MESH].indices;
       }
-      get recommendedViewportScale() {
-          return this[PRIVATE$g].recommendedViewportScale;
+      get lastChangedTime() {
+          return this[P_MESH].lastChangedTime;
       }
-      requestViewportScale(scale) {
-          if (scale === null || scale <= 0 || scale > 1) {
-              console.warn('Invalid scale value. Scale must be > 0 and <= 1.');
-              return;
-          }
-          this[PRIVATE$g].requestedViewportScale = scale;
+      get semanticLabel() {
+          return this[P_MESH].semanticLabel;
+      }
+  }
+  class XRMeshSet extends Set {
+  }
+  class NativeMesh {
+      constructor(transform, vertices, indices, semanticLabel) {
+          this.transform = transform;
+          this.vertices = vertices;
+          this.indices = indices;
+          this.semanticLabel = semanticLabel;
       }
   }
 
@@ -1908,16 +2029,30 @@
    * This source code is licensed under the MIT license found in the
    * LICENSE file in the root directory of this source tree.
    */
-  const PRIVATE$f = Symbol('@immersive-web-emulation-runtime/xr-joint-space');
-  class XRJointSpace extends XRSpace {
-      constructor(jointName, parentSpace, offsetMatrix) {
-          super(parentSpace, offsetMatrix);
-          this[PRIVATE$f] = { jointName, radius: 0 };
-      }
-      get jointName() {
-          return this[PRIVATE$f].jointName;
-      }
-  }
+  // Source: https://github.com/immersive-web/semantic-labels/blob/master/labels.json
+  /**
+   * Enum for semantic labels.
+   * For more details, see the {@link https://github.com/immersive-web/semantic-labels | Semantic Labels Documentation}.
+   */
+  exports.XRSemanticLabels = void 0;
+  (function (XRSemanticLabels) {
+      XRSemanticLabels["Desk"] = "desk";
+      XRSemanticLabels["Couch"] = "couch";
+      XRSemanticLabels["Floor"] = "floor";
+      XRSemanticLabels["Ceiling"] = "ceiling";
+      XRSemanticLabels["Wall"] = "wall";
+      XRSemanticLabels["Door"] = "door";
+      XRSemanticLabels["Window"] = "window";
+      XRSemanticLabels["Table"] = "table";
+      XRSemanticLabels["Shelf"] = "shelf";
+      XRSemanticLabels["Bed"] = "bed";
+      XRSemanticLabels["Screen"] = "screen";
+      XRSemanticLabels["Lamp"] = "lamp";
+      XRSemanticLabels["Plant"] = "plant";
+      XRSemanticLabels["WallArt"] = "wall art";
+      XRSemanticLabels["GlobalMesh"] = "global mesh";
+      XRSemanticLabels["Other"] = "other";
+  })(exports.XRSemanticLabels || (exports.XRSemanticLabels = {}));
 
   /**
    * Copyright (c) Meta Platforms, Inc. and affiliates.
@@ -1925,27 +2060,68 @@
    * This source code is licensed under the MIT license found in the
    * LICENSE file in the root directory of this source tree.
    */
-  const PRIVATE$e = Symbol('@immersive-web-emulation-runtime/xr-pose');
-  class XRPose {
-      constructor(transform, emulatedPosition = false, linearVelocity = undefined, angularVelocity = undefined) {
-          this[PRIVATE$e] = {
-              transform,
-              emulatedPosition,
-              linearVelocity,
-              angularVelocity,
+  var XRPlaneOrientation;
+  (function (XRPlaneOrientation) {
+      XRPlaneOrientation["Horizontal"] = "horizontal";
+      XRPlaneOrientation["Vertical"] = "vertical";
+  })(XRPlaneOrientation || (XRPlaneOrientation = {}));
+  /**
+   * XRPlane orientation mapping from semantic labels.
+   * For more details, see the {@link https://github.com/immersive-web/semantic-labels | Semantic Labels Documentation}.
+   */
+  const XREntityOrientation = {
+      [exports.XRSemanticLabels.Desk]: XRPlaneOrientation.Horizontal,
+      [exports.XRSemanticLabels.Couch]: XRPlaneOrientation.Horizontal,
+      [exports.XRSemanticLabels.Floor]: XRPlaneOrientation.Horizontal,
+      [exports.XRSemanticLabels.Ceiling]: XRPlaneOrientation.Horizontal,
+      [exports.XRSemanticLabels.Wall]: XRPlaneOrientation.Vertical,
+      [exports.XRSemanticLabels.Door]: XRPlaneOrientation.Vertical,
+      [exports.XRSemanticLabels.Window]: XRPlaneOrientation.Vertical,
+      [exports.XRSemanticLabels.Table]: XRPlaneOrientation.Horizontal,
+      [exports.XRSemanticLabels.Shelf]: XRPlaneOrientation.Horizontal,
+      [exports.XRSemanticLabels.Bed]: XRPlaneOrientation.Horizontal,
+      [exports.XRSemanticLabels.Screen]: XRPlaneOrientation.Horizontal,
+      [exports.XRSemanticLabels.Lamp]: XRPlaneOrientation.Horizontal,
+      [exports.XRSemanticLabels.Plant]: XRPlaneOrientation.Horizontal,
+      [exports.XRSemanticLabels.WallArt]: XRPlaneOrientation.Vertical,
+  };
+  class XRPlane {
+      constructor(nativePlane, planeSpace, polygon, semanticLabel) {
+          this[P_PLANE] = {
+              nativePlane,
+              frame: undefined,
+              planeSpace,
+              polygon,
+              lastChangedTime: performance.now(),
+              semanticLabel,
+              orientation: semanticLabel
+                  ? XREntityOrientation[semanticLabel]
+                  : undefined,
           };
       }
-      get transform() {
-          return this[PRIVATE$e].transform;
+      get planeSpace() {
+          return this[P_PLANE].planeSpace;
       }
-      get emulatedPosition() {
-          return this[PRIVATE$e].emulatedPosition;
+      get polygon() {
+          return this[P_PLANE].polygon;
       }
-      get linearVelocity() {
-          return this[PRIVATE$e].linearVelocity;
+      get orientation() {
+          return this[P_PLANE].orientation;
       }
-      get angularVelocity() {
-          return this[PRIVATE$e].angularVelocity;
+      get lastChangedTime() {
+          return this[P_PLANE].lastChangedTime;
+      }
+      get semanticLabel() {
+          return this[P_PLANE].semanticLabel;
+      }
+  }
+  class XRPlaneSet extends Set {
+  }
+  class NativePlane {
+      constructor(transform, polygon, semanticLabel) {
+          this.transform = transform;
+          this.polygon = polygon;
+          this.semanticLabel = semanticLabel;
       }
   }
 
@@ -1955,14 +2131,68 @@
    * This source code is licensed under the MIT license found in the
    * LICENSE file in the root directory of this source tree.
    */
-  const PRIVATE$d = Symbol('@immersive-web-emulation-runtime/xr-joint-pose');
-  class XRJointPose extends XRPose {
-      constructor(transform, radius, emulatedPosition = false, linearVelocity = undefined, angularVelocity = undefined) {
-          super(transform, emulatedPosition, linearVelocity, angularVelocity);
-          this[PRIVATE$d] = { radius };
+  class XRAnchor {
+      constructor(anchorSpace, session) {
+          this[P_ANCHOR] = {
+              anchorSpace,
+              session,
+              deleted: false,
+          };
+          session[P_SESSION].trackedAnchors.add(this);
       }
-      get radius() {
-          return this[PRIVATE$d].radius;
+      get anchorSpace() {
+          if (this[P_ANCHOR].deleted) {
+              throw new DOMException('XRAnchor has already been deleted.', 'InvalidStateError');
+          }
+          return this[P_ANCHOR].anchorSpace;
+      }
+      requestPersistentHandle() {
+          return new Promise((resolve, reject) => {
+              if (this[P_ANCHOR].deleted) {
+                  reject(new DOMException('XRAnchor has already been deleted.', 'InvalidStateError'));
+              }
+              else {
+                  const persistentAnchors = this[P_ANCHOR].session[P_SESSION].persistentAnchors;
+                  for (const [uuid, anchor] of persistentAnchors.entries()) {
+                      if (anchor === this) {
+                          resolve(uuid);
+                          return;
+                      }
+                  }
+                  const uuid = crypto.randomUUID();
+                  XRAnchorUtils.createPersistentAnchor(this[P_ANCHOR].session, this, uuid);
+                  resolve(uuid);
+              }
+          });
+      }
+      delete() {
+          if (this[P_ANCHOR].deleted) {
+              return;
+          }
+          this[P_ANCHOR].anchorSpace = null;
+          this[P_ANCHOR].deleted = true;
+          this[P_ANCHOR].session[P_SESSION].trackedAnchors.delete(this);
+      }
+  }
+  class XRAnchorSet extends Set {
+  }
+  const PersistentAnchorsStorageKey = '@immersive-web-emulation-runtime/persistent-anchors';
+  class XRAnchorUtils {
+      static recoverPersistentAnchorsFromStorage(session) {
+          const persistentAnchors = JSON.parse(localStorage.getItem(PersistentAnchorsStorageKey) || '{}');
+          Object.entries(persistentAnchors).forEach(([uuid, offsetMatrix]) => {
+              const globalSpace = session[P_SESSION].device[P_DEVICE].globalSpace;
+              const anchorSpace = new XRSpace(globalSpace, offsetMatrix);
+              const anchor = new XRAnchor(anchorSpace, session);
+              session[P_SESSION].persistentAnchors.set(uuid, anchor);
+          });
+      }
+      static createPersistentAnchor(session, anchor, uuid) {
+          session[P_SESSION].trackedAnchors.add(anchor);
+          session[P_SESSION].persistentAnchors.set(uuid, anchor);
+          const persistentAnchors = JSON.parse(localStorage.getItem(PersistentAnchorsStorageKey) || '{}');
+          persistentAnchors[uuid] = Array.from(anchor[P_ANCHOR].anchorSpace[P_SPACE].offsetMatrix);
+          localStorage.setItem(PersistentAnchorsStorageKey, JSON.stringify(persistentAnchors));
       }
   }
 
@@ -1994,7 +2224,7 @@
           return { x: this.x, y: this.y, z: this.z, w: this.w };
       }
   }
-  const DOMPointReadOnly = typeof globalThis.DOMPointReadOnly !== 'undefined'
+  const DOMPointReadOnly$1 = typeof globalThis.DOMPointReadOnly !== 'undefined'
       ? globalThis.DOMPointReadOnly
       : PolyfillDOMPointReadOnly;
 
@@ -2004,13 +2234,12 @@
    * This source code is licensed under the MIT license found in the
    * LICENSE file in the root directory of this source tree.
    */
-  const PRIVATE$c = Symbol('@immersive-web-emulation-runtime/xr-rigid-transform');
   class XRRigidTransform {
       constructor(position, orientation) {
           // Default values
           const defaultPosition = fromValues$2(0, 0, 0);
           const defaultOrientation = create();
-          this[PRIVATE$c] = {
+          this[P_RIGID_TRANSFORM] = {
               matrix: create$3(),
               position: position
                   ? fromValues$2(position.x, position.y, position.z)
@@ -2023,23 +2252,23 @@
           this.updateMatrix();
       }
       updateMatrix() {
-          fromRotationTranslation(this[PRIVATE$c].matrix, this[PRIVATE$c].orientation, this[PRIVATE$c].position);
+          fromRotationTranslation(this[P_RIGID_TRANSFORM].matrix, this[P_RIGID_TRANSFORM].orientation, this[P_RIGID_TRANSFORM].position);
       }
       get matrix() {
-          return this[PRIVATE$c].matrix;
+          return this[P_RIGID_TRANSFORM].matrix;
       }
       get position() {
-          const pos = this[PRIVATE$c].position;
-          return new DOMPointReadOnly(pos[0], pos[1], pos[2], 1);
+          const pos = this[P_RIGID_TRANSFORM].position;
+          return new DOMPointReadOnly$1(pos[0], pos[1], pos[2], 1);
       }
       get orientation() {
-          const ori = this[PRIVATE$c].orientation;
-          return new DOMPointReadOnly(ori[0], ori[1], ori[2], ori[3]);
+          const ori = this[P_RIGID_TRANSFORM].orientation;
+          return new DOMPointReadOnly$1(ori[0], ori[1], ori[2], ori[3]);
       }
       get inverse() {
-          if (!this[PRIVATE$c].inverse) {
+          if (!this[P_RIGID_TRANSFORM].inverse) {
               const invMatrix = create$3();
-              if (!invert(invMatrix, this[PRIVATE$c].matrix)) {
+              if (!invert(invMatrix, this[P_RIGID_TRANSFORM].matrix)) {
                   throw new Error('Matrix is not invertible.');
               }
               // Decomposing the inverse matrix into position and orientation
@@ -2048,30 +2277,101 @@
               let invOrientation = create();
               getRotation(invOrientation, invMatrix);
               // Creating a new XRRigidTransform for the inverse
-              this[PRIVATE$c].inverse = new XRRigidTransform(new DOMPointReadOnly(invPosition[0], invPosition[1], invPosition[2], 1), new DOMPointReadOnly(invOrientation[0], invOrientation[1], invOrientation[2], invOrientation[3]));
+              this[P_RIGID_TRANSFORM].inverse = new XRRigidTransform(new DOMPointReadOnly$1(invPosition[0], invPosition[1], invPosition[2], 1), new DOMPointReadOnly$1(invOrientation[0], invOrientation[1], invOrientation[2], invOrientation[3]));
               // Setting the inverse of the inverse to be this transform
-              this[PRIVATE$c].inverse[PRIVATE$c].inverse = this;
+              this[P_RIGID_TRANSFORM].inverse[P_RIGID_TRANSFORM].inverse = this;
           }
-          return this[PRIVATE$c].inverse;
+          return this[P_RIGID_TRANSFORM].inverse;
       }
   }
 
-  /**
-   * Copyright (c) Meta Platforms, Inc. and affiliates.
-   *
-   * This source code is licensed under the MIT license found in the
-   * LICENSE file in the root directory of this source tree.
-   */
-  const PRIVATE$b = Symbol('@immersive-web-emulation-runtime/xr-viewer-pose');
-  class XRViewerPose extends XRPose {
-      constructor(transform, views, emulatedPosition = false, linearVelocity = undefined, angularVelocity = undefined) {
-          super(transform, emulatedPosition, linearVelocity, angularVelocity);
-          this[PRIVATE$b] = {
-              views: Object.freeze(views),
+  class DOMPointReadOnly {
+      constructor(x = 0, y = 0, z = 0, w = 1) {
+          this.x = x;
+          this.y = y;
+          this.z = z;
+          this.w = w;
+      }
+  }
+  class XRRay {
+      constructor(origin, direction) {
+          const _origin = { x: 0, y: 0, z: 0, w: 1 };
+          const _direction = { x: 0, y: 0, z: -1, w: 0 };
+          if (origin instanceof XRRigidTransform) {
+              const transform = origin;
+              const matrix = transform.matrix;
+              const originVec4 = set$1(create$1(), _origin.x, _origin.y, _origin.z, _origin.w);
+              const directionVec4 = set$1(create$1(), _direction.x, _direction.y, _direction.z, _direction.w);
+              transformMat4(originVec4, originVec4, matrix);
+              transformMat4(directionVec4, directionVec4, matrix);
+              _origin.x = originVec4[0];
+              _origin.y = originVec4[1];
+              _origin.z = originVec4[2];
+              _origin.w = originVec4[3];
+              _direction.x = directionVec4[0];
+              _direction.y = directionVec4[1];
+              _direction.z = directionVec4[2];
+              _direction.w = directionVec4[3];
+          }
+          else {
+              if (origin) {
+                  _origin.x = origin.x;
+                  _origin.y = origin.y;
+                  _origin.z = origin.z;
+                  _origin.w = origin.w;
+              }
+              if (direction) {
+                  if ((direction.x === 0 && direction.y === 0 && direction.z === 0) ||
+                      direction.w !== 1) {
+                      throw new DOMException('Invalid direction value to construct XRRay', 'TypeError');
+                  }
+                  _direction.x = direction.x;
+                  _direction.y = direction.y;
+                  _direction.z = direction.z;
+                  _direction.w = direction.w;
+              }
+          }
+          const length = Math.sqrt(_direction.x * _direction.x +
+              _direction.y * _direction.y +
+              _direction.z * _direction.z) || 1;
+          _direction.x = _direction.x / length;
+          _direction.y = _direction.y / length;
+          _direction.z = _direction.z / length;
+          this[P_RAY] = {
+              origin: new DOMPointReadOnly(_origin.x, _origin.y, _origin.z, _origin.w),
+              direction: new DOMPointReadOnly(_direction.x, _direction.y, _direction.z, _direction.w),
+              matrix: null,
           };
       }
-      get views() {
-          return this[PRIVATE$b].views;
+      get origin() {
+          return this[P_RAY].origin;
+      }
+      get direction() {
+          return this[P_RAY].direction;
+      }
+      get matrix() {
+          if (this[P_RAY].matrix) {
+              return this[P_RAY].matrix;
+          }
+          const z = set$2(create$2(), 0, 0, -1);
+          const origin = set$2(create$2(), this[P_RAY].origin.x, this[P_RAY].origin.y, this[P_RAY].origin.z);
+          const direction = set$2(create$2(), this[P_RAY].direction.x, this[P_RAY].direction.y, this[P_RAY].direction.z);
+          const axis = cross(create$2(), direction, z);
+          const cosAngle = dot(direction, z);
+          const rotation = create$3();
+          if (cosAngle > -1 && cosAngle < 1) {
+              fromRotation(rotation, Math.acos(cosAngle), axis);
+          }
+          else if (cosAngle === -1) {
+              fromRotation(rotation, Math.acos(cosAngle), set$2(create$2(), 1, 0, 0));
+          }
+          else {
+              identity(rotation);
+          }
+          const translation = fromTranslation(create$3(), origin);
+          const matrix = multiply$1(create$3(), translation, rotation);
+          this[P_RAY].matrix = new Float32Array(matrix);
+          return this[P_RAY].matrix;
       }
   }
 
@@ -2081,111 +2381,28 @@
    * This source code is licensed under the MIT license found in the
    * LICENSE file in the root directory of this source tree.
    */
-  const PRIVATE$a = Symbol('@immersive-web-emulation-runtime/xr-frame');
-  const spaceGlobalMatrix = create$3();
-  const baseSpaceGlobalMatrix = create$3();
-  const baseSpaceGlobalMatrixInverse = create$3();
-  const getOffsetMatrix = (offsetMatrix, space, baseSpace) => {
-      XRSpaceUtils.calculateGlobalOffsetMatrix(space, spaceGlobalMatrix);
-      XRSpaceUtils.calculateGlobalOffsetMatrix(baseSpace, baseSpaceGlobalMatrix);
-      invert(baseSpaceGlobalMatrixInverse, baseSpaceGlobalMatrix);
-      multiply$1(offsetMatrix, baseSpaceGlobalMatrixInverse, spaceGlobalMatrix);
-  };
-  class XRFrame {
-      constructor(session, id, active, animationFrame, predictedDisplayTime) {
-          this[PRIVATE$a] = {
+  class XRHitTestSource {
+      constructor(session, options) {
+          var _a;
+          this[P_HIT_TEST] = {
               session,
-              id,
-              active,
-              animationFrame,
-              predictedDisplayTime,
-              tempMat4: create$3(),
+              space: options.space,
+              offsetRay: (_a = options.offsetRay) !== null && _a !== void 0 ? _a : new XRRay(),
           };
       }
-      get session() {
-          return this[PRIVATE$a].session;
-      }
-      get predictedDisplayTime() {
-          return this[PRIVATE$a].predictedDisplayTime;
-      }
-      getPose(space, baseSpace) {
-          if (!this[PRIVATE$a].active) {
-              throw new DOMException('XRFrame access outside the callback that produced it is invalid.', 'InvalidStateError');
-          }
-          getOffsetMatrix(this[PRIVATE$a].tempMat4, space, baseSpace);
-          const position = create$2();
-          getTranslation(position, this[PRIVATE$a].tempMat4);
-          const orientation = create();
-          getRotation(orientation, this[PRIVATE$a].tempMat4);
-          return new XRPose(new XRRigidTransform({ x: position[0], y: position[1], z: position[2], w: 1.0 }, {
-              x: orientation[0],
-              y: orientation[1],
-              z: orientation[2],
-              w: orientation[3],
-          }), space[PRIVATE$l].emulated);
+      cancel() {
+          this[P_HIT_TEST].session[P_SESSION].hitTestSources.delete(this);
       }
-      getViewerPose(referenceSpace) {
-          if (!this[PRIVATE$a].animationFrame) {
-              throw new DOMException('getViewerPose can only be called on XRFrame objects passed to XRSession.requestAnimationFrame callbacks.', 'InvalidStateError');
-          }
-          const session = this[PRIVATE$a].session;
-          const device = session[PRIVATE$6].device;
-          const pose = this.getPose(device.viewerSpace, referenceSpace);
-          const eyes = session[PRIVATE$6].mode === XRSessionMode.Inline
-              ? [XREye.None]
-              : [XREye.Left, XREye.Right];
-          const views = [];
-          eyes.forEach((eye) => {
-              const viewSpace = device.viewSpaces[eye];
-              const viewPose = this.getPose(viewSpace, referenceSpace);
-              const projectionMatrix = session[PRIVATE$6].getProjectionMatrix(eye);
-              const view = new XRView(eye, new Float32Array(projectionMatrix), viewPose.transform, session);
-              views.push(view);
-          });
-          return new XRViewerPose(pose.transform, views, false);
-      }
-      getJointPose(joint, baseSpace) {
-          const xrPose = this.getPose(joint, baseSpace);
-          const radius = joint[PRIVATE$f].radius;
-          return new XRJointPose(xrPose.transform, radius, false);
+  }
+  class XRHitTestResult {
+      constructor(frame, offsetSpace) {
+          this[P_HIT_TEST] = { frame, offsetSpace };
       }
-      fillJointRadii(jointSpaces, radii) {
-          // converting from sequence type to array
-          jointSpaces = Array.from(jointSpaces);
-          if (!this[PRIVATE$a].active) {
-              throw new DOMException('XRFrame access outside the callback that produced it is invalid.', 'InvalidStateError');
-          }
-          if (jointSpaces.length > radii.length) {
-              throw new DOMException('The length of jointSpaces is larger than the number of elements in radii', 'TypeError');
-          }
-          let allValid = true;
-          for (let offset = 0; offset < jointSpaces.length; offset++) {
-              if (!jointSpaces[offset][PRIVATE$f].radius) {
-                  radii[offset] = NaN;
-                  allValid = false;
-              }
-              else {
-                  radii[offset] = jointSpaces[offset][PRIVATE$f].radius;
-              }
-          }
-          return allValid;
+      getPose(baseSpace) {
+          return this[P_HIT_TEST].frame.getPose(this[P_HIT_TEST].offsetSpace, baseSpace);
       }
-      fillPoses(spaces, baseSpace, transforms) {
-          // converting from sequence type to array
-          spaces = Array.from(spaces);
-          if (!this[PRIVATE$a].active) {
-              throw new DOMException('XRFrame access outside the callback that produced it is invalid.', 'InvalidStateError');
-          }
-          if (spaces.length * 16 > transforms.length) {
-              throw new DOMException('The length of spaces multiplied by 16 is larger than the number of elements in transforms', 'TypeError');
-          }
-          spaces.forEach((space, i) => {
-              getOffsetMatrix(this[PRIVATE$a].tempMat4, space, baseSpace);
-              for (let j = 0; j < 16; j++) {
-                  transforms[i * 16 + j] = this[PRIVATE$a].tempMat4[j];
-              }
-          });
-          return true;
+      createAnchor() {
+          return this[P_HIT_TEST].frame.createAnchor(new XRRigidTransform(), this[P_HIT_TEST].offsetSpace);
       }
   }
 
@@ -2220,7 +2437,6 @@
    * LICENSE file in the root directory of this source tree.
    */
   var _a;
-  const PRIVATE$9 = Symbol('@immersive-web-emulation-runtime/xr-reference-space');
   var XRReferenceSpaceType;
   (function (XRReferenceSpaceType) {
       XRReferenceSpaceType["Viewer"] = "viewer";
@@ -2236,17 +2452,17 @@
               type: null,
               onreset: () => { },
           };
-          this[PRIVATE$9].type = type;
+          this[P_REF_SPACE].type = type;
       }
       get onreset() {
           var _b;
-          return (_b = this[PRIVATE$9].onreset) !== null && _b !== void 0 ? _b : (() => { });
+          return (_b = this[P_REF_SPACE].onreset) !== null && _b !== void 0 ? _b : (() => { });
       }
       set onreset(callback) {
-          if (this[PRIVATE$9].onreset) {
-              this.removeEventListener('reset', this[PRIVATE$9].onreset);
+          if (this[P_REF_SPACE].onreset) {
+              this.removeEventListener('reset', this[P_REF_SPACE].onreset);
           }
-          this[PRIVATE$9].onreset = callback;
+          this[P_REF_SPACE].onreset = callback;
           if (callback) {
               this.addEventListener('reset', callback);
           }
@@ -2255,10 +2471,10 @@
       getOffsetReferenceSpace(originOffset) {
           // Create a new XRReferenceSpace with the originOffset as its offsetMatrix
           // The new space's parent is set to 'this' (the current XRReferenceSpace)
-          return new XRReferenceSpace(this[PRIVATE$9].type, this, originOffset);
+          return new XRReferenceSpace(this[P_REF_SPACE].type, this, originOffset);
       }
   }
-  _a = PRIVATE$9;
+  _a = P_REF_SPACE;
 
   /**
    * Copyright (c) Meta Platforms, Inc. and affiliates.
@@ -2266,10 +2482,9 @@
    * This source code is licensed under the MIT license found in the
    * LICENSE file in the root directory of this source tree.
    */
-  const PRIVATE$8 = Symbol('@immersive-web-emulation-runtime/xr-render-state');
   class XRRenderState {
       constructor(init = {}, oldState) {
-          this[PRIVATE$8] = {
+          this[P_RENDER_STATE] = {
               depthNear: init.depthNear || (oldState === null || oldState === void 0 ? void 0 : oldState.depthNear) || 0.1,
               depthFar: init.depthFar || (oldState === null || oldState === void 0 ? void 0 : oldState.depthFar) || 1000.0,
               inlineVerticalFieldOfView: init.inlineVerticalFieldOfView ||
@@ -2279,16 +2494,16 @@
           };
       }
       get depthNear() {
-          return this[PRIVATE$8].depthNear;
+          return this[P_RENDER_STATE].depthNear;
       }
       get depthFar() {
-          return this[PRIVATE$8].depthFar;
+          return this[P_RENDER_STATE].depthFar;
       }
       get inlineVerticalFieldOfView() {
-          return this[PRIVATE$8].inlineVerticalFieldOfView;
+          return this[P_RENDER_STATE].inlineVerticalFieldOfView;
       }
       get baseLayer() {
-          return this[PRIVATE$8].baseLayer;
+          return this[P_RENDER_STATE].baseLayer;
       }
   }
 
@@ -2314,67 +2529,269 @@
    * This source code is licensed under the MIT license found in the
    * LICENSE file in the root directory of this source tree.
    */
-  class XRLayer extends EventTarget {
+  var XREye;
+  (function (XREye) {
+      XREye["None"] = "none";
+      XREye["Left"] = "left";
+      XREye["Right"] = "right";
+  })(XREye || (XREye = {}));
+  class XRView {
+      constructor(eye, projectionMatrix, transform, session) {
+          this[P_VIEW] = {
+              eye,
+              projectionMatrix,
+              transform,
+              recommendedViewportScale: null,
+              requestedViewportScale: 1.0,
+              session,
+          };
+      }
+      get eye() {
+          return this[P_VIEW].eye;
+      }
+      get projectionMatrix() {
+          return this[P_VIEW].projectionMatrix;
+      }
+      get transform() {
+          return this[P_VIEW].transform;
+      }
+      get recommendedViewportScale() {
+          return this[P_VIEW].recommendedViewportScale;
+      }
+      requestViewportScale(scale) {
+          if (scale === null || scale <= 0 || scale > 1) {
+              console.warn('Invalid scale value. Scale must be > 0 and <= 1.');
+              return;
+          }
+          this[P_VIEW].requestedViewportScale = scale;
+      }
   }
-  const PRIVATE$7 = Symbol('@immersive-web-emulation-runtime/XRWebGLLayer');
-  const defaultLayerInit = {
-      antialias: true,
-      depth: true,
-      stencil: false,
-      alpha: true,
-      ignoreDepthValues: false,
-      framebufferScaleFactor: 1.0,
+
+  /**
+   * Copyright (c) Meta Platforms, Inc. and affiliates.
+   *
+   * This source code is licensed under the MIT license found in the
+   * LICENSE file in the root directory of this source tree.
+   */
+  class XRPose {
+      constructor(transform, emulatedPosition = false, linearVelocity = undefined, angularVelocity = undefined) {
+          this[P_POSE] = {
+              transform,
+              emulatedPosition,
+              linearVelocity,
+              angularVelocity,
+          };
+      }
+      get transform() {
+          return this[P_POSE].transform;
+      }
+      get emulatedPosition() {
+          return this[P_POSE].emulatedPosition;
+      }
+      get linearVelocity() {
+          return this[P_POSE].linearVelocity;
+      }
+      get angularVelocity() {
+          return this[P_POSE].angularVelocity;
+      }
+  }
+
+  /**
+   * Copyright (c) Meta Platforms, Inc. and affiliates.
+   *
+   * This source code is licensed under the MIT license found in the
+   * LICENSE file in the root directory of this source tree.
+   */
+  class XRJointPose extends XRPose {
+      constructor(transform, radius, emulatedPosition = false, linearVelocity = undefined, angularVelocity = undefined) {
+          super(transform, emulatedPosition, linearVelocity, angularVelocity);
+          this[P_JOINT_POSE] = { radius };
+      }
+      get radius() {
+          return this[P_JOINT_POSE].radius;
+      }
+  }
+
+  /**
+   * Copyright (c) Meta Platforms, Inc. and affiliates.
+   *
+   * This source code is licensed under the MIT license found in the
+   * LICENSE file in the root directory of this source tree.
+   */
+  class XRViewerPose extends XRPose {
+      constructor(transform, views, emulatedPosition = false, linearVelocity = undefined, angularVelocity = undefined) {
+          super(transform, emulatedPosition, linearVelocity, angularVelocity);
+          this[P_VIEWER_POSE] = {
+              views: Object.freeze(views),
+          };
+      }
+      get views() {
+          return this[P_VIEWER_POSE].views;
+      }
+  }
+
+  /**
+   * Copyright (c) Meta Platforms, Inc. and affiliates.
+   *
+   * This source code is licensed under the MIT license found in the
+   * LICENSE file in the root directory of this source tree.
+   */
+  const spaceGlobalMatrix = create$3();
+  const baseSpaceGlobalMatrix = create$3();
+  const baseSpaceGlobalMatrixInverse = create$3();
+  const getOffsetMatrix = (offsetMatrix, space, baseSpace) => {
+      XRSpaceUtils.calculateGlobalOffsetMatrix(space, spaceGlobalMatrix);
+      XRSpaceUtils.calculateGlobalOffsetMatrix(baseSpace, baseSpaceGlobalMatrix);
+      invert(baseSpaceGlobalMatrixInverse, baseSpaceGlobalMatrix);
+      multiply$1(offsetMatrix, baseSpaceGlobalMatrixInverse, spaceGlobalMatrix);
   };
-  class XRWebGLLayer extends XRLayer {
-      constructor(session, context, layerInit = {}) {
-          super();
-          if (session[PRIVATE$6].ended) {
-              throw new DOMException('Session has ended', 'InvalidStateError');
-          }
-          // TO-DO: Check that the context attribute has xrCompatible set to true
-          // may require polyfilling the context and perhaps canvas.getContext
-          // Default values for XRWebGLLayerInit, can be overridden by layerInit
-          const config = { ...defaultLayerInit, ...layerInit };
-          this[PRIVATE$7] = {
+  class XRFrame {
+      constructor(session, id, active, animationFrame, predictedDisplayTime) {
+          this[P_FRAME] = {
               session,
-              context,
-              antialias: config.antialias,
+              id,
+              active,
+              animationFrame,
+              predictedDisplayTime,
+              tempMat4: create$3(),
+              detectedPlanes: new XRPlaneSet(),
+              detectedMeshes: new XRMeshSet(),
+              trackedAnchors: session[P_SESSION].frameTrackedAnchors,
+              hitTestResultsMap: new Map(),
           };
       }
-      get context() {
-          return this[PRIVATE$7].context;
+      get session() {
+          return this[P_FRAME].session;
       }
-      get antialias() {
-          return this[PRIVATE$7].antialias;
+      get predictedDisplayTime() {
+          return this[P_FRAME].predictedDisplayTime;
       }
-      get ignoreDepthValues() {
+      getPose(space, baseSpace) {
+          if (!this[P_FRAME].active) {
+              throw new DOMException('XRFrame access outside the callback that produced it is invalid.', 'InvalidStateError');
+          }
+          getOffsetMatrix(this[P_FRAME].tempMat4, space, baseSpace);
+          const position = create$2();
+          getTranslation(position, this[P_FRAME].tempMat4);
+          const orientation = create();
+          getRotation(orientation, this[P_FRAME].tempMat4);
+          return new XRPose(new XRRigidTransform({ x: position[0], y: position[1], z: position[2], w: 1.0 }, {
+              x: orientation[0],
+              y: orientation[1],
+              z: orientation[2],
+              w: orientation[3],
+          }), space[P_SPACE].emulated);
+      }
+      getViewerPose(referenceSpace) {
+          if (!this[P_FRAME].animationFrame) {
+              throw new DOMException('getViewerPose can only be called on XRFrame objects passed to XRSession.requestAnimationFrame callbacks.', 'InvalidStateError');
+          }
+          const session = this[P_FRAME].session;
+          const device = session[P_SESSION].device;
+          const pose = this.getPose(device.viewerSpace, referenceSpace);
+          const eyes = session[P_SESSION].mode === 'inline'
+              ? [XREye.None]
+              : [XREye.Left, XREye.Right];
+          const views = [];
+          eyes.forEach((eye) => {
+              const viewSpace = device.viewSpaces[eye];
+              const viewPose = this.getPose(viewSpace, referenceSpace);
+              const projectionMatrix = session[P_SESSION].getProjectionMatrix(eye);
+              const view = new XRView(eye, new Float32Array(projectionMatrix), viewPose.transform, session);
+              views.push(view);
+          });
+          return new XRViewerPose(pose.transform, views, false);
+      }
+      getJointPose(joint, baseSpace) {
+          const xrPose = this.getPose(joint, baseSpace);
+          const radius = joint[P_JOINT_SPACE].radius;
+          return new XRJointPose(xrPose.transform, radius, false);
+      }
+      fillJointRadii(jointSpaces, radii) {
+          // converting from sequence type to array
+          jointSpaces = Array.from(jointSpaces);
+          if (!this[P_FRAME].active) {
+              throw new DOMException('XRFrame access outside the callback that produced it is invalid.', 'InvalidStateError');
+          }
+          if (jointSpaces.length > radii.length) {
+              throw new DOMException('The length of jointSpaces is larger than the number of elements in radii', 'TypeError');
+          }
+          let allValid = true;
+          for (let offset = 0; offset < jointSpaces.length; offset++) {
+              if (!jointSpaces[offset][P_JOINT_SPACE].radius) {
+                  radii[offset] = NaN;
+                  allValid = false;
+              }
+              else {
+                  radii[offset] = jointSpaces[offset][P_JOINT_SPACE].radius;
+              }
+          }
+          return allValid;
+      }
+      fillPoses(spaces, baseSpace, transforms) {
+          // converting from sequence type to array
+          spaces = Array.from(spaces);
+          if (!this[P_FRAME].active) {
+              throw new DOMException('XRFrame access outside the callback that produced it is invalid.', 'InvalidStateError');
+          }
+          if (spaces.length * 16 > transforms.length) {
+              throw new DOMException('The length of spaces multiplied by 16 is larger than the number of elements in transforms', 'TypeError');
+          }
+          spaces.forEach((space, i) => {
+              getOffsetMatrix(this[P_FRAME].tempMat4, space, baseSpace);
+              for (let j = 0; j < 16; j++) {
+                  transforms[i * 16 + j] = this[P_FRAME].tempMat4[j];
+              }
+          });
           return true;
       }
-      get framebuffer() {
-          return null;
-      }
-      get framebufferWidth() {
-          return this[PRIVATE$7].context.drawingBufferWidth;
+      get detectedPlanes() {
+          if (!this[P_FRAME].active) {
+              throw new DOMException('XRFrame access outside the callback that produced it is invalid.', 'InvalidStateError');
+          }
+          return this[P_FRAME].detectedPlanes;
       }
-      get framebufferHeight() {
-          return this[PRIVATE$7].context.drawingBufferHeight;
+      get detectedMeshes() {
+          if (!this[P_FRAME].active) {
+              throw new DOMException('XRFrame access outside the callback that produced it is invalid.', 'InvalidStateError');
+          }
+          return this[P_FRAME].detectedMeshes;
       }
-      getViewport(view) {
-          if (view[PRIVATE$g].session !== this[PRIVATE$7].session) {
-              throw new DOMException("View's session differs from Layer's session", 'InvalidStateError');
+      get trackedAnchors() {
+          if (!this[P_FRAME].active) {
+              throw new DOMException('XRFrame access outside the callback that produced it is invalid.', 'InvalidStateError');
           }
-          // TO-DO: check frame
-          return this[PRIVATE$7].session[PRIVATE$6].device[PRIVATE$1].getViewport(this, view);
+          return this[P_FRAME].trackedAnchors;
       }
-      static getNativeFramebufferScaleFactor(session) {
-          if (!(session instanceof XRSession)) {
-              throw new TypeError('getNativeFramebufferScaleFactor must be passed a session.');
+      createAnchor(pose, space) {
+          return new Promise((resolve, reject) => {
+              if (!this[P_FRAME].active) {
+                  reject(new DOMException('XRFrame access outside the callback that produced it is invalid.', 'InvalidStateError'));
+              }
+              else {
+                  const globalSpace = this[P_FRAME].session[P_SESSION].device[P_DEVICE].globalSpace;
+                  const tempSpace = new XRSpace(space, pose.matrix);
+                  const globalOffsetMatrix = XRSpaceUtils.calculateGlobalOffsetMatrix(tempSpace);
+                  const anchorSpace = new XRSpace(globalSpace, globalOffsetMatrix);
+                  const anchor = new XRAnchor(anchorSpace, this[P_FRAME].session);
+                  this[P_FRAME].session[P_SESSION].trackedAnchors.add(anchor);
+                  this[P_FRAME].session[P_SESSION].newAnchors.set(anchor, {
+                      resolve,
+                      reject,
+                  });
+              }
+          });
+      }
+      getHitTestResults(hitTestSource) {
+          if (!this[P_FRAME].active) {
+              throw new DOMException('XRFrame access outside the callback that produced it is invalid.', 'InvalidStateError');
           }
-          if (session[PRIVATE$6].ended) {
-              return 0.0;
+          else if (!this[P_FRAME].hitTestResultsMap.has(hitTestSource)) {
+              throw new DOMException('Requested hit test results are not available for current frame.', 'InvalidStateError');
+          }
+          else {
+              return [...this[P_FRAME].hitTestResultsMap.get(hitTestSource)];
           }
-          // Return 1.0 for simplicity, actual implementation might vary based on the device capabilities
-          return 1.0;
       }
   }
 
@@ -2384,18 +2801,6 @@
    * This source code is licensed under the MIT license found in the
    * LICENSE file in the root directory of this source tree.
    */
-  var XRVisibilityState;
-  (function (XRVisibilityState) {
-      XRVisibilityState["Visible"] = "visible";
-      XRVisibilityState["VisibleBlurred"] = "visible-blurred";
-      XRVisibilityState["Hidden"] = "hidden";
-  })(XRVisibilityState || (XRVisibilityState = {}));
-  var XRSessionMode;
-  (function (XRSessionMode) {
-      XRSessionMode["Inline"] = "inline";
-      XRSessionMode["ImmersiveVR"] = "immersive-vr";
-      XRSessionMode["ImmersiveAR"] = "immersive-ar";
-  })(XRSessionMode || (XRSessionMode = {}));
   var XREnvironmentBlendMode;
   (function (XREnvironmentBlendMode) {
       XREnvironmentBlendMode["Opaque"] = "opaque";
@@ -2407,11 +2812,10 @@
       XRInteractionMode["ScreenSpace"] = "screen-space";
       XRInteractionMode["WorldSpace"] = "world-space";
   })(XRInteractionMode || (XRInteractionMode = {}));
-  const PRIVATE$6 = Symbol('@immersive-web-emulation-runtime/xr-session');
   class XRSession extends EventTarget {
       constructor(device, mode, enabledFeatures) {
           super();
-          this[PRIVATE$6] = {
+          this[P_SESSION] = {
               device,
               mode,
               renderState: new XRRenderState(),
@@ -2425,10 +2829,10 @@
                   [XREye.None]: create$3(),
               },
               getProjectionMatrix: (eye) => {
-                  return this[PRIVATE$6].projectionMatrices[eye];
+                  return this[P_SESSION].projectionMatrices[eye];
               },
               referenceSpaceIsSupported: (referenceSpaceType) => {
-                  if (!this[PRIVATE$6].enabledFeatures.includes(referenceSpaceType)) {
+                  if (!this[P_SESSION].enabledFeatures.includes(referenceSpaceType)) {
                       return false;
                   }
                   switch (referenceSpaceType) {
@@ -2438,23 +2842,23 @@
                       case XRReferenceSpaceType.LocalFloor:
                       case XRReferenceSpaceType.BoundedFloor:
                       case XRReferenceSpaceType.Unbounded:
-                          return this[PRIVATE$6].mode != XRSessionMode.Inline;
+                          return this[P_SESSION].mode != 'inline';
                   }
               },
               frameHandle: 0,
               frameCallbacks: [],
               currentFrameCallbacks: null,
               onDeviceFrame: () => {
-                  if (this[PRIVATE$6].ended) {
+                  if (this[P_SESSION].ended) {
                       return;
                   }
-                  this[PRIVATE$6].deviceFrameHandle = globalThis.requestAnimationFrame(this[PRIVATE$6].onDeviceFrame);
-                  if (this[PRIVATE$6].pendingRenderState != null) {
-                      this[PRIVATE$6].renderState = this[PRIVATE$6].pendingRenderState;
-                      this[PRIVATE$6].pendingRenderState = null;
-                      this[PRIVATE$6].device[PRIVATE$1].onBaseLayerSet(this[PRIVATE$6].renderState.baseLayer);
+                  this[P_SESSION].deviceFrameHandle = globalThis.requestAnimationFrame(this[P_SESSION].onDeviceFrame);
+                  if (this[P_SESSION].pendingRenderState != null) {
+                      this[P_SESSION].renderState = this[P_SESSION].pendingRenderState;
+                      this[P_SESSION].pendingRenderState = null;
+                      this[P_SESSION].device[P_DEVICE].onBaseLayerSet(this[P_SESSION].renderState.baseLayer);
                   }
-                  const baseLayer = this[PRIVATE$6].renderState.baseLayer;
+                  const baseLayer = this[P_SESSION].renderState.baseLayer;
                   if (baseLayer === null) {
                       return;
                   }
@@ -2488,7 +2892,7 @@
                    * prevent rendering artifacts from past frames. It ensures that each new frame starts
                    * with a clean slate.
                    */
-                  if (this[PRIVATE$6].mode != XRSessionMode.Inline) {
+                  if (this[P_SESSION].mode != 'inline') {
                       const currentClearColor = context.getParameter(context.COLOR_CLEAR_VALUE);
                       const currentClearDepth = context.getParameter(context.DEPTH_CLEAR_VALUE);
                       const currentClearStencil = context.getParameter(context.STENCIL_CLEAR_VALUE);
@@ -2503,20 +2907,33 @@
                       context.clearStencil(currentClearStencil);
                   }
                   // Calculate projection matrices
-                  const { depthNear, depthFar } = this[PRIVATE$6].renderState;
+                  const { depthNear, depthFar } = this[P_SESSION].renderState;
                   const { width, height } = canvas;
-                  if (this[PRIVATE$6].mode !== XRSessionMode.Inline) {
-                      const aspect = (width * (this[PRIVATE$6].device.stereoEnabled ? 0.5 : 1.0)) / height;
-                      perspective(this[PRIVATE$6].projectionMatrices[XREye.Left], this[PRIVATE$6].device.fovy, aspect, depthNear, depthFar);
-                      copy$3(this[PRIVATE$6].projectionMatrices[XREye.Right], this[PRIVATE$6].projectionMatrices[XREye.Left]);
+                  if (this[P_SESSION].mode !== 'inline') {
+                      const aspect = (width * (this[P_SESSION].device.stereoEnabled ? 0.5 : 1.0)) /
+                          height;
+                      perspective(this[P_SESSION].projectionMatrices[XREye.Left], this[P_SESSION].device.fovy, aspect, depthNear, depthFar);
+                      copy$3(this[P_SESSION].projectionMatrices[XREye.Right], this[P_SESSION].projectionMatrices[XREye.Left]);
                   }
                   else {
                       const aspect = width / height;
-                      perspective(this[PRIVATE$6].projectionMatrices[XREye.None], this[PRIVATE$6].renderState.inlineVerticalFieldOfView, aspect, depthNear, depthFar);
+                      perspective(this[P_SESSION].projectionMatrices[XREye.None], this[P_SESSION].renderState.inlineVerticalFieldOfView, aspect, depthNear, depthFar);
+                  }
+                  const frame = new XRFrame(this, this[P_SESSION].frameHandle, true, true, performance.now());
+                  if (this[P_SESSION].enabledFeatures.includes('anchors')) {
+                      this[P_SESSION].updateTrackedAnchors();
                   }
-                  const frame = new XRFrame(this, this[PRIVATE$6].frameHandle, true, true, performance.now());
-                  this[PRIVATE$6].device[PRIVATE$1].onFrameStart(frame);
-                  this[PRIVATE$6].updateActiveInputSources();
+                  if (this[P_SESSION].enabledFeatures.includes('plane-detection')) {
+                      this[P_SESSION].updateTrackedPlanes(frame);
+                  }
+                  if (this[P_SESSION].enabledFeatures.includes('mesh-detection')) {
+                      this[P_SESSION].updateTrackedMeshes(frame);
+                  }
+                  if (this[P_SESSION].enabledFeatures.includes('hit-test')) {
+                      this[P_SESSION].computeHitTestResults(frame);
+                  }
+                  this[P_SESSION].device[P_DEVICE].onFrameStart(frame);
+                  this[P_SESSION].updateActiveInputSources();
                   /*
                    * For each entry in callbacks, in order:
                    * - If the entry’s cancelled boolean is true, continue to the next entry.
@@ -2525,10 +2942,10 @@
                    */
                   // - Let callbacks be a list of the entries in session’s list of animation frame
                   //   callback, in the order in which they were added to the list.
-                  const callbacks = (this[PRIVATE$6].currentFrameCallbacks =
-                      this[PRIVATE$6].frameCallbacks);
+                  const callbacks = (this[P_SESSION].currentFrameCallbacks =
+                      this[P_SESSION].frameCallbacks);
                   // - Set session’s list of animation frame callbacks to the empty list.
-                  this[PRIVATE$6].frameCallbacks = [];
+                  this[P_SESSION].frameCallbacks = [];
                   const rightNow = performance.now();
                   for (let i = 0; i < callbacks.length; i++) {
                       try {
@@ -2540,21 +2957,21 @@
                           console.error(err);
                       }
                   }
-                  this[PRIVATE$6].currentFrameCallbacks = null;
+                  this[P_SESSION].currentFrameCallbacks = null;
                   // - Set frame’s active boolean to false.
-                  frame[PRIVATE$a].active = false;
+                  frame[P_FRAME].active = false;
               },
               nominalFrameRate: device.internalNominalFrameRate,
               referenceSpaces: [],
               inputSourceArray: [],
               activeInputSources: [],
               updateActiveInputSources: () => {
-                  const handTrackingOn = this[PRIVATE$6].enabledFeatures.includes(WebXRFeatures.HandTracking);
-                  const prevInputs = this[PRIVATE$6].activeInputSources;
-                  const currInputs = this[PRIVATE$6].device.inputSources.filter((inputSource) => !inputSource.hand || handTrackingOn);
+                  const handTrackingOn = this[P_SESSION].enabledFeatures.includes('hand-tracking');
+                  const prevInputs = this[P_SESSION].activeInputSources;
+                  const currInputs = this[P_SESSION].device.inputSources.filter((inputSource) => !inputSource.hand || handTrackingOn);
                   const added = currInputs.filter((item) => !prevInputs.includes(item));
                   const removed = prevInputs.filter((item) => !currInputs.includes(item));
-                  this[PRIVATE$6].activeInputSources = currInputs;
+                  this[P_SESSION].activeInputSources = currInputs;
                   if (added.length > 0 || removed.length > 0) {
                       this.dispatchEvent(new XRInputSourcesChangeEvent('inputsourceschange', {
                           session: this,
@@ -2563,6 +2980,89 @@
                       }));
                   }
               },
+              trackedAnchors: new XRAnchorSet(),
+              persistentAnchors: new Map(),
+              newAnchors: new Map(),
+              frameTrackedAnchors: new XRAnchorSet(),
+              updateTrackedAnchors: () => {
+                  if (this[P_SESSION].enabledFeatures.includes('anchors')) {
+                      this[P_SESSION].frameTrackedAnchors.clear();
+                      Array.from(this[P_SESSION].trackedAnchors).forEach((anchor) => {
+                          if (anchor[P_ANCHOR].deleted) {
+                              this[P_SESSION].trackedAnchors.delete(anchor);
+                              if (this[P_SESSION].newAnchors.has(anchor)) {
+                                  const { reject } = this[P_SESSION].newAnchors.get(anchor);
+                                  reject(new DOMException('Anchor is no longer tracked', 'InvalidStateError'));
+                              }
+                          }
+                          else {
+                              this[P_SESSION].frameTrackedAnchors.add(anchor);
+                              if (this[P_SESSION].newAnchors.has(anchor)) {
+                                  const { resolve } = this[P_SESSION].newAnchors.get(anchor);
+                                  resolve(anchor);
+                                  this[P_SESSION].newAnchors.delete(anchor);
+                              }
+                          }
+                      });
+                  }
+              },
+              trackedPlanes: new Map(),
+              updateTrackedPlanes: (frame) => {
+                  const sem = this[P_SESSION].device[P_DEVICE].syntheticEnvironmentModule;
+                  if (!sem) {
+                      return;
+                  }
+                  sem.trackedPlanes.forEach((plane) => {
+                      let xrPlane = this[P_SESSION].trackedPlanes.get(plane);
+                      if (!xrPlane) {
+                          const planeSpace = new XRSpace(this[P_SESSION].device[P_DEVICE].globalSpace, plane.transform.matrix);
+                          xrPlane = new XRPlane(plane, planeSpace, plane.polygon);
+                          this[P_SESSION].trackedPlanes.set(plane, xrPlane);
+                      }
+                      xrPlane[P_PLANE].lastChangedTime = frame.predictedDisplayTime;
+                      xrPlane[P_PLANE].frame = frame;
+                      frame[P_FRAME].detectedPlanes.add(xrPlane);
+                  });
+              },
+              trackedMeshes: new Map(),
+              updateTrackedMeshes: (frame) => {
+                  const sem = this[P_SESSION].device[P_DEVICE].syntheticEnvironmentModule;
+                  if (!sem) {
+                      return;
+                  }
+                  sem.trackedMeshes.forEach((mesh) => {
+                      let xrMesh = this[P_SESSION].trackedMeshes.get(mesh);
+                      if (!xrMesh) {
+                          const meshSpace = new XRSpace(this[P_SESSION].device[P_DEVICE].globalSpace, mesh.transform.matrix);
+                          xrMesh = new XRMesh(mesh, meshSpace, mesh.vertices, mesh.indices);
+                          this[P_SESSION].trackedMeshes.set(mesh, xrMesh);
+                      }
+                      xrMesh[P_MESH].lastChangedTime = frame.predictedDisplayTime;
+                      xrMesh[P_MESH].frame = frame;
+                      frame[P_FRAME].detectedMeshes.add(xrMesh);
+                  });
+              },
+              hitTestSources: new Set(),
+              computeHitTestResults: (frame) => {
+                  const sem = this[P_SESSION].device[P_DEVICE].syntheticEnvironmentModule;
+                  if (!sem)
+                      return;
+                  const globalSpace = this[P_SESSION].device[P_DEVICE].globalSpace;
+                  this[P_SESSION].hitTestSources.forEach((hitTestSource) => {
+                      const sourceSpace = hitTestSource[P_HIT_TEST].space;
+                      const sourceGlobalOffset = XRSpaceUtils.calculateGlobalOffsetMatrix(sourceSpace);
+                      const rayLocalOffset = hitTestSource[P_HIT_TEST].offsetRay.matrix;
+                      const rayGlobalOffset = create$3();
+                      multiply$1(rayGlobalOffset, sourceGlobalOffset, rayLocalOffset);
+                      const hitTestResults = [];
+                      sem.computeHitTestResults(rayGlobalOffset).forEach((matrix) => {
+                          const offsetSpace = new XRSpace(globalSpace, matrix);
+                          const hitTestResult = new XRHitTestResult(frame, offsetSpace);
+                          hitTestResults.push(hitTestResult);
+                      });
+                      frame[P_FRAME].hitTestResultsMap.set(hitTestSource, hitTestResults);
+                  });
+              },
               onend: null,
               oninputsourceschange: null,
               onselect: null,
@@ -2574,87 +3074,87 @@
               onvisibilitychange: null,
               onframeratechange: null,
           };
+          XRAnchorUtils.recoverPersistentAnchorsFromStorage(this);
           // start the frameloop
-          this[PRIVATE$6].onDeviceFrame();
+          this[P_SESSION].onDeviceFrame();
       }
       get visibilityState() {
-          return this[PRIVATE$6].device.visibilityState;
+          return this[P_SESSION].device.visibilityState;
       }
       get frameRate() {
-          return this[PRIVATE$6].nominalFrameRate;
+          return this[P_SESSION].nominalFrameRate;
       }
       get supportedFrameRates() {
-          return new Float32Array(this[PRIVATE$6].device.supportedFrameRates);
+          return new Float32Array(this[P_SESSION].device.supportedFrameRates);
       }
       get renderState() {
-          return this[PRIVATE$6].renderState;
+          return this[P_SESSION].renderState;
       }
       get inputSources() {
           // use the same array object
-          this[PRIVATE$6].inputSourceArray.length = 0;
-          if (!this[PRIVATE$6].ended && this[PRIVATE$6].mode !== XRSessionMode.Inline) {
-              this[PRIVATE$6].inputSourceArray.push(...this[PRIVATE$6].activeInputSources);
+          this[P_SESSION].inputSourceArray.length = 0;
+          if (!this[P_SESSION].ended && this[P_SESSION].mode !== 'inline') {
+              this[P_SESSION].inputSourceArray.push(...this[P_SESSION].activeInputSources);
           }
-          return this[PRIVATE$6].inputSourceArray;
+          return this[P_SESSION].inputSourceArray;
       }
       get enabledFeatures() {
-          return this[PRIVATE$6].enabledFeatures;
+          return this[P_SESSION].enabledFeatures;
       }
       get isSystemKeyboardSupported() {
-          return this[PRIVATE$6].isSystemKeyboardSupported;
+          return this[P_SESSION].isSystemKeyboardSupported;
       }
       get environmentBlendMode() {
           var _a;
-          return ((_a = this[PRIVATE$6].device[PRIVATE$1].environmentBlendModes[this[PRIVATE$6].mode]) !== null && _a !== void 0 ? _a : XREnvironmentBlendMode.Opaque);
+          return ((_a = this[P_SESSION].device[P_DEVICE].environmentBlendModes[this[P_SESSION].mode]) !== null && _a !== void 0 ? _a : XREnvironmentBlendMode.Opaque);
       }
       get interactionMode() {
-          return this[PRIVATE$6].device[PRIVATE$1].interactionMode;
+          return this[P_SESSION].device[P_DEVICE].interactionMode;
       }
       updateRenderState(state = {}) {
           var _a, _b, _c, _d;
-          if (this[PRIVATE$6].ended) {
+          if (this[P_SESSION].ended) {
               throw new DOMException('XRSession has already ended.', 'InvalidStateError');
           }
-          if (state.baseLayer &&
-              state.baseLayer[PRIVATE$7].session !== this) {
+          if (state.baseLayer && state.baseLayer[P_WEBGL_LAYER].session !== this) {
               throw new DOMException('Base layer was created by a different XRSession', 'InvalidStateError');
           }
           if (state.inlineVerticalFieldOfView != null &&
-              this[PRIVATE$6].mode !== XRSessionMode.Inline) {
+              this[P_SESSION].mode !== 'inline') {
               throw new DOMException('InlineVerticalFieldOfView must not be set for an immersive session', 'InvalidStateError');
           }
           const compoundStateInit = {
               baseLayer: state.baseLayer ||
-                  ((_a = this[PRIVATE$6].pendingRenderState) === null || _a === void 0 ? void 0 : _a.baseLayer) ||
+                  ((_a = this[P_SESSION].pendingRenderState) === null || _a === void 0 ? void 0 : _a.baseLayer) ||
                   undefined,
               depthFar: state.depthFar ||
-                  ((_b = this[PRIVATE$6].pendingRenderState) === null || _b === void 0 ? void 0 : _b.depthFar) ||
+                  ((_b = this[P_SESSION].pendingRenderState) === null || _b === void 0 ? void 0 : _b.depthFar) ||
                   undefined,
               depthNear: state.depthNear ||
-                  ((_c = this[PRIVATE$6].pendingRenderState) === null || _c === void 0 ? void 0 : _c.depthNear) ||
+                  ((_c = this[P_SESSION].pendingRenderState) === null || _c === void 0 ? void 0 : _c.depthNear) ||
                   undefined,
               inlineVerticalFieldOfView: state.inlineVerticalFieldOfView ||
-                  ((_d = this[PRIVATE$6].pendingRenderState) === null || _d === void 0 ? void 0 : _d.inlineVerticalFieldOfView) ||
+                  ((_d = this[P_SESSION].pendingRenderState) === null || _d === void 0 ? void 0 : _d.inlineVerticalFieldOfView) ||
                   undefined,
           };
-          this[PRIVATE$6].pendingRenderState = new XRRenderState(compoundStateInit, this[PRIVATE$6].renderState);
+          this[P_SESSION].pendingRenderState = new XRRenderState(compoundStateInit, this[P_SESSION].renderState);
       }
       // the nominal frame rate updates are emulated, no actual update to the
       // display frame rate of the device will be executed
       async updateTargetFrameRate(rate) {
           return new Promise((resolve, reject) => {
-              if (this[PRIVATE$6].ended) {
+              if (this[P_SESSION].ended) {
                   reject(new DOMException('XRSession has already ended.', 'InvalidStateError'));
               }
-              else if (!this[PRIVATE$6].device.supportedFrameRates.includes(rate)) {
+              else if (!this[P_SESSION].device.supportedFrameRates.includes(rate)) {
                   reject(new DOMException('Requested frame rate not supported.', 'InvalidStateError'));
               }
               else {
-                  if (this[PRIVATE$6].nominalFrameRate === rate) {
+                  if (this[P_SESSION].nominalFrameRate === rate) {
                       console.log(`Requested frame rate is the same as the current nominal frame rate, no update made`);
                   }
                   else {
-                      this[PRIVATE$6].nominalFrameRate = rate;
+                      this[P_SESSION].nominalFrameRate = rate;
                       this.dispatchEvent(new XRSessionEvent('frameratechange', { session: this }));
                       console.log(`Nominal frame rate updated to ${rate}`);
                   }
@@ -2664,37 +3164,37 @@
       }
       async requestReferenceSpace(type) {
           return new Promise((resolve, reject) => {
-              if (this[PRIVATE$6].ended ||
-                  !this[PRIVATE$6].referenceSpaceIsSupported(type)) {
+              if (this[P_SESSION].ended ||
+                  !this[P_SESSION].referenceSpaceIsSupported(type)) {
                   reject(new DOMException('The requested reference space type is not supported.', 'NotSupportedError'));
                   return;
               }
               let referenceSpace;
               switch (type) {
                   case XRReferenceSpaceType.Viewer:
-                      referenceSpace = this[PRIVATE$6].device.viewerSpace;
+                      referenceSpace = this[P_SESSION].device.viewerSpace;
                       break;
                   case XRReferenceSpaceType.Local:
                       // creating an XRReferenceSpace with the current headset transform in global space
-                      referenceSpace = new XRReferenceSpace(type, this[PRIVATE$6].device[PRIVATE$1].globalSpace, this[PRIVATE$6].device.viewerSpace[PRIVATE$l].offsetMatrix);
+                      referenceSpace = new XRReferenceSpace(type, this[P_SESSION].device[P_DEVICE].globalSpace, this[P_SESSION].device.viewerSpace[P_SPACE].offsetMatrix);
                       break;
                   case XRReferenceSpaceType.LocalFloor:
                   case XRReferenceSpaceType.BoundedFloor:
                   case XRReferenceSpaceType.Unbounded:
                       // TO-DO: add boundary geometry for bounded-floor
-                      referenceSpace = new XRReferenceSpace(type, this[PRIVATE$6].device[PRIVATE$1].globalSpace);
+                      referenceSpace = new XRReferenceSpace(type, this[P_SESSION].device[P_DEVICE].globalSpace);
                       break;
               }
-              this[PRIVATE$6].referenceSpaces.push(referenceSpace);
+              this[P_SESSION].referenceSpaces.push(referenceSpace);
               resolve(referenceSpace);
           });
       }
       requestAnimationFrame(callback) {
-          if (this[PRIVATE$6].ended) {
+          if (this[P_SESSION].ended) {
               return 0;
           }
-          const frameHandle = ++this[PRIVATE$6].frameHandle;
-          this[PRIVATE$6].frameCallbacks.push({
+          const frameHandle = ++this[P_SESSION].frameHandle;
+          this[P_SESSION].frameCallbacks.push({
               handle: frameHandle,
               callback,
               cancelled: false,
@@ -2703,7 +3203,7 @@
       }
       cancelAnimationFrame(handle) {
           // Remove the callback with that handle from the queue
-          let callbacks = this[PRIVATE$6].frameCallbacks;
+          let callbacks = this[P_SESSION].frameCallbacks;
           let index = callbacks.findIndex((d) => d && d.handle === handle);
           if (index > -1) {
               callbacks[index].cancelled = true;
@@ -2711,7 +3211,7 @@
           }
           // If cancelAnimationFrame is called from within a frame callback, also check
           // the remaining callbacks for the current frame:
-          callbacks = this[PRIVATE$6].currentFrameCallbacks;
+          callbacks = this[P_SESSION].currentFrameCallbacks;
           if (callbacks) {
               index = callbacks.findIndex((d) => d && d.handle === handle);
               if (index > -1) {
@@ -2722,144 +3222,199 @@
       }
       async end() {
           return new Promise((resolve, reject) => {
-              if (this[PRIVATE$6].ended || this[PRIVATE$6].deviceFrameHandle === null) {
+              if (this[P_SESSION].ended || this[P_SESSION].deviceFrameHandle === null) {
                   reject(new DOMException('XRSession has already ended.', 'InvalidStateError'));
               }
               else {
-                  globalThis.cancelAnimationFrame(this[PRIVATE$6].deviceFrameHandle);
-                  this[PRIVATE$6].device[PRIVATE$1].onSessionEnd();
+                  globalThis.cancelAnimationFrame(this[P_SESSION].deviceFrameHandle);
+                  this[P_SESSION].device[P_DEVICE].onSessionEnd();
                   this.dispatchEvent(new XRSessionEvent('end', { session: this }));
                   resolve();
               }
           });
       }
+      // anchors
+      get persistentAnchors() {
+          return Array.from(this[P_SESSION].persistentAnchors.keys());
+      }
+      restorePersistentAnchor(uuid) {
+          return new Promise((resolve, reject) => {
+              if (!this[P_SESSION].persistentAnchors.has(uuid)) {
+                  reject(new DOMException(`Persistent anchor with uuid ${uuid} not found.`, 'InvalidStateError'));
+              }
+              else if (this[P_SESSION].ended) {
+                  reject(new DOMException('XRSession has already ended.', 'InvalidStateError'));
+              }
+              else {
+                  const anchor = this[P_SESSION].persistentAnchors.get(uuid);
+                  if (this[P_SESSION].newAnchors.has(anchor)) {
+                      reject(new DOMException(`Multiple concurrent attempts detected to restore the anchor with UUID: ${uuid}.`, 'InvalidStateError'));
+                  }
+                  else {
+                      this[P_SESSION].trackedAnchors.add(anchor);
+                      this[P_SESSION].newAnchors.set(anchor, { resolve, reject });
+                  }
+              }
+          });
+      }
+      deletePersistentAnchor(uuid) {
+          return new Promise((resolve, reject) => {
+              if (!this[P_SESSION].persistentAnchors.has(uuid)) {
+                  reject(new DOMException(`Persistent anchor with uuid ${uuid} not found.`, 'InvalidStateError'));
+              }
+              else {
+                  const anchor = this[P_SESSION].persistentAnchors.get(uuid);
+                  this[P_SESSION].persistentAnchors.delete(uuid);
+                  anchor.delete();
+                  resolve(undefined);
+              }
+          });
+      }
+      requestHitTestSource(options) {
+          return new Promise((resolve, reject) => {
+              if (!this[P_SESSION].enabledFeatures.includes('hit-test')) {
+                  reject(new DOMException(`WebXR feature "hit-test" is not supported by current session`, 'NotSupportedError'));
+              }
+              else if (this[P_SESSION].ended) {
+                  reject(new DOMException('XRSession has already ended.', 'InvalidStateError'));
+              }
+              else if (!this[P_SESSION].device[P_DEVICE].syntheticEnvironmentModule) {
+                  reject(new DOMException('Synthethic Environment Module required for emulating hit-test', 'OperationError'));
+              }
+              else {
+                  const xrHitTestSource = new XRHitTestSource(this, options);
+                  this[P_SESSION].hitTestSources.add(xrHitTestSource);
+                  resolve(xrHitTestSource);
+              }
+          });
+      }
       // events
       get onend() {
           var _a;
-          return (_a = this[PRIVATE$6].onend) !== null && _a !== void 0 ? _a : (() => { });
+          return (_a = this[P_SESSION].onend) !== null && _a !== void 0 ? _a : (() => { });
       }
       set onend(callback) {
-          if (this[PRIVATE$6].onend) {
-              this.removeEventListener('end', this[PRIVATE$6].onend);
+          if (this[P_SESSION].onend) {
+              this.removeEventListener('end', this[P_SESSION].onend);
           }
-          this[PRIVATE$6].onend = callback;
+          this[P_SESSION].onend = callback;
           if (callback) {
               this.addEventListener('end', callback);
           }
       }
       get oninputsourceschange() {
           var _a;
-          return (_a = this[PRIVATE$6].oninputsourceschange) !== null && _a !== void 0 ? _a : (() => { });
+          return (_a = this[P_SESSION].oninputsourceschange) !== null && _a !== void 0 ? _a : (() => { });
       }
       set oninputsourceschange(callback) {
-          if (this[PRIVATE$6].oninputsourceschange) {
-              this.removeEventListener('inputsourceschange', this[PRIVATE$6].oninputsourceschange);
+          if (this[P_SESSION].oninputsourceschange) {
+              this.removeEventListener('inputsourceschange', this[P_SESSION].oninputsourceschange);
           }
-          this[PRIVATE$6].oninputsourceschange = callback;
+          this[P_SESSION].oninputsourceschange = callback;
           if (callback) {
               this.addEventListener('inputsourceschange', callback);
           }
       }
       get onselect() {
           var _a;
-          return (_a = this[PRIVATE$6].onselect) !== null && _a !== void 0 ? _a : (() => { });
+          return (_a = this[P_SESSION].onselect) !== null && _a !== void 0 ? _a : (() => { });
       }
       set onselect(callback) {
-          if (this[PRIVATE$6].onselect) {
-              this.removeEventListener('select', this[PRIVATE$6].onselect);
+          if (this[P_SESSION].onselect) {
+              this.removeEventListener('select', this[P_SESSION].onselect);
           }
-          this[PRIVATE$6].onselect = callback;
+          this[P_SESSION].onselect = callback;
           if (callback) {
               this.addEventListener('select', callback);
           }
       }
       get onselectstart() {
           var _a;
-          return (_a = this[PRIVATE$6].onselectstart) !== null && _a !== void 0 ? _a : (() => { });
+          return (_a = this[P_SESSION].onselectstart) !== null && _a !== void 0 ? _a : (() => { });
       }
       set onselectstart(callback) {
-          if (this[PRIVATE$6].onselectstart) {
-              this.removeEventListener('selectstart', this[PRIVATE$6].onselectstart);
+          if (this[P_SESSION].onselectstart) {
+              this.removeEventListener('selectstart', this[P_SESSION].onselectstart);
           }
-          this[PRIVATE$6].onselectstart = callback;
+          this[P_SESSION].onselectstart = callback;
           if (callback) {
               this.addEventListener('selectstart', callback);
           }
       }
       get onselectend() {
           var _a;
-          return (_a = this[PRIVATE$6].onselectend) !== null && _a !== void 0 ? _a : (() => { });
+          return (_a = this[P_SESSION].onselectend) !== null && _a !== void 0 ? _a : (() => { });
       }
       set onselectend(callback) {
-          if (this[PRIVATE$6].onselectend) {
-              this.removeEventListener('selectend', this[PRIVATE$6].onselectend);
+          if (this[P_SESSION].onselectend) {
+              this.removeEventListener('selectend', this[P_SESSION].onselectend);
           }
-          this[PRIVATE$6].onselectend = callback;
+          this[P_SESSION].onselectend = callback;
           if (callback) {
               this.addEventListener('selectend', callback);
           }
       }
       get onsqueeze() {
           var _a;
-          return (_a = this[PRIVATE$6].onsqueeze) !== null && _a !== void 0 ? _a : (() => { });
+          return (_a = this[P_SESSION].onsqueeze) !== null && _a !== void 0 ? _a : (() => { });
       }
       set onsqueeze(callback) {
-          if (this[PRIVATE$6].onsqueeze) {
-              this.removeEventListener('squeeze', this[PRIVATE$6].onsqueeze);
+          if (this[P_SESSION].onsqueeze) {
+              this.removeEventListener('squeeze', this[P_SESSION].onsqueeze);
           }
-          this[PRIVATE$6].onsqueeze = callback;
+          this[P_SESSION].onsqueeze = callback;
           if (callback) {
               this.addEventListener('squeeze', callback);
           }
       }
       get onsqueezestart() {
           var _a;
-          return (_a = this[PRIVATE$6].onsqueezestart) !== null && _a !== void 0 ? _a : (() => { });
+          return (_a = this[P_SESSION].onsqueezestart) !== null && _a !== void 0 ? _a : (() => { });
       }
       set onsqueezestart(callback) {
-          if (this[PRIVATE$6].onsqueezestart) {
-              this.removeEventListener('squeezestart', this[PRIVATE$6].onsqueezestart);
+          if (this[P_SESSION].onsqueezestart) {
+              this.removeEventListener('squeezestart', this[P_SESSION].onsqueezestart);
           }
-          this[PRIVATE$6].onsqueezestart = callback;
+          this[P_SESSION].onsqueezestart = callback;
           if (callback) {
               this.addEventListener('squeezestart', callback);
           }
       }
       get onsqueezeend() {
           var _a;
-          return (_a = this[PRIVATE$6].onsqueezeend) !== null && _a !== void 0 ? _a : (() => { });
+          return (_a = this[P_SESSION].onsqueezeend) !== null && _a !== void 0 ? _a : (() => { });
       }
       set onsqueezeend(callback) {
-          if (this[PRIVATE$6].onsqueezeend) {
-              this.removeEventListener('squeezeend', this[PRIVATE$6].onsqueezeend);
+          if (this[P_SESSION].onsqueezeend) {
+              this.removeEventListener('squeezeend', this[P_SESSION].onsqueezeend);
           }
-          this[PRIVATE$6].onsqueezeend = callback;
+          this[P_SESSION].onsqueezeend = callback;
           if (callback) {
               this.addEventListener('squeezeend', callback);
           }
       }
       get onvisibilitychange() {
           var _a;
-          return (_a = this[PRIVATE$6].onvisibilitychange) !== null && _a !== void 0 ? _a : (() => { });
+          return (_a = this[P_SESSION].onvisibilitychange) !== null && _a !== void 0 ? _a : (() => { });
       }
       set onvisibilitychange(callback) {
-          if (this[PRIVATE$6].onvisibilitychange) {
-              this.removeEventListener('visibilitychange', this[PRIVATE$6].onvisibilitychange);
+          if (this[P_SESSION].onvisibilitychange) {
+              this.removeEventListener('visibilitychange', this[P_SESSION].onvisibilitychange);
           }
-          this[PRIVATE$6].onvisibilitychange = callback;
+          this[P_SESSION].onvisibilitychange = callback;
           if (callback) {
               this.addEventListener('visibilitychange', callback);
           }
       }
       get onframeratechange() {
           var _a;
-          return (_a = this[PRIVATE$6].onframeratechange) !== null && _a !== void 0 ? _a : (() => { });
+          return (_a = this[P_SESSION].onframeratechange) !== null && _a !== void 0 ? _a : (() => { });
       }
       set onframeratechange(callback) {
-          if (this[PRIVATE$6].onframeratechange) {
-              this.removeEventListener('frameratechange', this[PRIVATE$6].onframeratechange);
+          if (this[P_SESSION].onframeratechange) {
+              this.removeEventListener('frameratechange', this[P_SESSION].onframeratechange);
           }
-          this[PRIVATE$6].onframeratechange = callback;
+          this[P_SESSION].onframeratechange = callback;
           if (callback) {
               this.addEventListener('frameratechange', callback);
           }
@@ -2903,6 +3458,22 @@
   class XRHand extends Map {
   }
 
+  /**
+   * Copyright (c) Meta Platforms, Inc. and affiliates.
+   *
+   * This source code is licensed under the MIT license found in the
+   * LICENSE file in the root directory of this source tree.
+   */
+  class XRJointSpace extends XRSpace {
+      constructor(jointName, parentSpace, offsetMatrix) {
+          super(parentSpace, offsetMatrix);
+          this[P_JOINT_SPACE] = { jointName, radius: 0 };
+      }
+      get jointName() {
+          return this[P_JOINT_SPACE].jointName;
+      }
+  }
+
   /**
    * Copyright (c) Meta Platforms, Inc. and affiliates.
    *
@@ -3684,7 +4255,6 @@
           matrixLeft[i] *= mirrorMultiplierMatrix[i];
       }
   };
-  const PRIVATE$5 = Symbol('@immersive-web-emulation-runtime/xr-hand-input');
   class XRHandInput extends XRTrackedInput {
       constructor(handInputConfig, handedness, globalSpace) {
           if (handedness !== XRHandedness.Left && handedness !== XRHandedness.Right) {
@@ -3705,53 +4275,51 @@
           });
           const inputSource = new XRInputSource(handedness, XRTargetRayMode.TrackedPointer, profiles, targetRaySpace, new Gamepad(XRHandGamepadConfig), gripSpace, hand);
           super(inputSource);
-          this[PRIVATE$5] = {
+          this[P_HAND_INPUT] = {
               poseId: 'default',
               poses: handInputConfig.poses,
           };
           this.updateHandPose();
       }
       get poseId() {
-          return this[PRIVATE$5].poseId;
+          return this[P_HAND_INPUT].poseId;
       }
       set poseId(poseId) {
-          if (!this[PRIVATE$5].poses[poseId]) {
+          if (!this[P_HAND_INPUT].poses[poseId]) {
               console.warn(`Pose config ${poseId} not found`);
               return;
           }
-          this[PRIVATE$5].poseId = poseId;
+          this[P_HAND_INPUT].poseId = poseId;
       }
       updateHandPose() {
-          const targetPose = this[PRIVATE$5].poses[this[PRIVATE$5].poseId];
-          const pinchPose = this[PRIVATE$5].poses.pinch;
+          const targetPose = this[P_HAND_INPUT].poses[this[P_HAND_INPUT].poseId];
+          const pinchPose = this[P_HAND_INPUT].poses.pinch;
           Object.values(XRHandJoint).forEach((jointName) => {
               const targetJointMatrix = targetPose.jointTransforms[jointName].offsetMatrix;
               const pinchJointMatrix = pinchPose.jointTransforms[jointName].offsetMatrix;
               const jointSpace = this.inputSource.hand.get(jointName);
-              interpolateMatrix(jointSpace[PRIVATE$l].offsetMatrix, targetJointMatrix, pinchJointMatrix, this.pinchValue);
+              interpolateMatrix(jointSpace[P_SPACE].offsetMatrix, targetJointMatrix, pinchJointMatrix, this.pinchValue);
               if (this.inputSource.handedness === XRHandedness.Right) {
-                  mirrorMatrixToRight(jointSpace[PRIVATE$l].offsetMatrix);
+                  mirrorMatrixToRight(jointSpace[P_SPACE].offsetMatrix);
               }
-              jointSpace[PRIVATE$f].radius =
+              jointSpace[P_JOINT_SPACE].radius =
                   (1 - this.pinchValue) * targetPose.jointTransforms[jointName].radius +
                       this.pinchValue * pinchPose.jointTransforms[jointName].radius;
           });
           if (targetPose.gripOffsetMatrix && pinchPose.gripOffsetMatrix) {
-              interpolateMatrix(this.inputSource.gripSpace[PRIVATE$l].offsetMatrix, targetPose.gripOffsetMatrix, pinchPose.gripOffsetMatrix, this.pinchValue);
+              interpolateMatrix(this.inputSource.gripSpace[P_SPACE].offsetMatrix, targetPose.gripOffsetMatrix, pinchPose.gripOffsetMatrix, this.pinchValue);
           }
       }
       get pinchValue() {
-          return this[PRIVATE$i].inputSource.gamepad[PRIVATE$k]
-              .buttonsMap['pinch'].value;
+          return this[P_TRACKED_INPUT].inputSource.gamepad[P_GAMEPAD].buttonsMap['pinch'].value;
       }
       updatePinchValue(value) {
           if (value > 1 || value < 0) {
               console.warn(`Out-of-range value ${value} provided for pinch`);
               return;
           }
-          const gamepadButton = this[PRIVATE$i].inputSource.gamepad[PRIVATE$k]
-              .buttonsMap['pinch'];
-          gamepadButton[PRIVATE$k].pendingValue = value;
+          const gamepadButton = this[P_TRACKED_INPUT].inputSource.gamepad[P_GAMEPAD].buttonsMap['pinch'];
+          gamepadButton[P_GAMEPAD].pendingValue = value;
       }
       onFrameStart(frame) {
           super.onFrameStart(frame);
@@ -3765,66 +4333,66 @@
    * This source code is licensed under the MIT license found in the
    * LICENSE file in the root directory of this source tree.
    */
-  const PRIVATE$4 = Symbol('@immersive-web-emulation-runtime/xr-system');
-  class XRSystem extends EventTarget {
-      constructor(device) {
+  class XRLayer extends EventTarget {
+  }
+  const defaultLayerInit = {
+      antialias: true,
+      depth: true,
+      stencil: false,
+      alpha: true,
+      ignoreDepthValues: false,
+      framebufferScaleFactor: 1.0,
+  };
+  class XRWebGLLayer extends XRLayer {
+      constructor(session, context, layerInit = {}) {
           super();
-          this[PRIVATE$4] = { device };
-          // Initialize device change monitoring here if applicable
+          if (session[P_SESSION].ended) {
+              throw new DOMException('Session has ended', 'InvalidStateError');
+          }
+          // TO-DO: Check that the context attribute has xrCompatible set to true
+          // may require polyfilling the context and perhaps canvas.getContext
+          // Default values for XRWebGLLayerInit, can be overridden by layerInit
+          const config = { ...defaultLayerInit, ...layerInit };
+          this[P_WEBGL_LAYER] = {
+              session,
+              context,
+              antialias: config.antialias,
+          };
       }
-      isSessionSupported(mode) {
-          return new Promise((resolve, _reject) => {
-              if (mode === XRSessionMode.Inline) {
-                  resolve(true);
-              }
-              else {
-                  // Check for spatial tracking permission if necessary
-                  resolve(this[PRIVATE$4].device.supportedSessionModes.includes(mode));
-              }
-          });
+      get context() {
+          return this[P_WEBGL_LAYER].context;
       }
-      requestSession(mode, options = {}) {
-          return new Promise((resolve, reject) => {
-              this.isSessionSupported(mode)
-                  .then((isSupported) => {
-                  if (!isSupported) {
-                      reject(new DOMException('The requested XRSession mode is not supported.', 'NotSupportedError'));
-                      return;
-                  }
-                  // Check for active sessions and other constraints here
-                  if (this[PRIVATE$4].activeSession) {
-                      reject(new DOMException('An active XRSession already exists.', 'InvalidStateError'));
-                      return;
-                  }
-                  // Handle required and optional features
-                  const { requiredFeatures = [], optionalFeatures = [] } = options;
-                  const { supportedFeatures } = this[PRIVATE$4].device;
-                  // Check if all required features are supported
-                  const allRequiredSupported = requiredFeatures.every((feature) => supportedFeatures.includes(feature));
-                  if (!allRequiredSupported) {
-                      reject(new Error('One or more required features are not supported by the device.'));
-                      return;
-                  }
-                  // Filter out unsupported optional features
-                  const supportedOptionalFeatures = optionalFeatures.filter((feature) => supportedFeatures.includes(feature));
-                  // Combine required and supported optional features into enabled features
-                  const enabledFeatures = Array.from(new Set([
-                      ...requiredFeatures,
-                      ...supportedOptionalFeatures,
-                      WebXRFeatures.Viewer,
-                      WebXRFeatures.Local,
-                  ]));
-                  // Proceed with session creation
-                  const session = new XRSession(this[PRIVATE$4].device, mode, enabledFeatures);
-                  this[PRIVATE$4].activeSession = session;
-                  // Listen for session end to clear the active session
-                  session.addEventListener('end', () => {
-                      this[PRIVATE$4].activeSession = undefined;
-                  });
-                  resolve(session);
-              })
-                  .catch(reject);
-          });
+      get antialias() {
+          return this[P_WEBGL_LAYER].antialias;
+      }
+      get ignoreDepthValues() {
+          return true;
+      }
+      get framebuffer() {
+          return null;
+      }
+      get framebufferWidth() {
+          return this[P_WEBGL_LAYER].context.drawingBufferWidth;
+      }
+      get framebufferHeight() {
+          return this[P_WEBGL_LAYER].context.drawingBufferHeight;
+      }
+      getViewport(view) {
+          if (view[P_VIEW].session !== this[P_WEBGL_LAYER].session) {
+              throw new DOMException("View's session differs from Layer's session", 'InvalidStateError');
+          }
+          // TO-DO: check frame
+          return this[P_WEBGL_LAYER].session[P_SESSION].device[P_DEVICE].getViewport(this, view);
+      }
+      static getNativeFramebufferScaleFactor(session) {
+          if (!(session instanceof XRSession)) {
+              throw new TypeError('getNativeFramebufferScaleFactor must be passed a session.');
+          }
+          if (session[P_SESSION].ended) {
+              return 0.0;
+          }
+          // Return 1.0 for simplicity, actual implementation might vary based on the device capabilities
+          return 1.0;
       }
   }
 
@@ -3834,7 +4402,6 @@
    * This source code is licensed under the MIT license found in the
    * LICENSE file in the root directory of this source tree.
    */
-  const PRIVATE$3 = Symbol('@immersive-web-emulation-runtime/action-player');
   class ActionPlayer {
       constructor(refSpace, recording, ipd) {
           const { schema, frames } = recording;
@@ -3847,7 +4414,7 @@
               [XREye.Right]: new XRSpace(viewerSpace),
               [XREye.None]: new XRSpace(viewerSpace),
           };
-          this[PRIVATE$3] = {
+          this[P_ACTION_PLAYER] = {
               refSpace,
               inputSources: new Map(),
               inputSchemas: new Map(),
@@ -3862,8 +4429,8 @@
               vec3: create$2(),
               quat: create(),
           };
-          fromTranslation(this[PRIVATE$3].viewSpaces[XREye.Left][PRIVATE$l].offsetMatrix, fromValues$2(-ipd / 2, 0, 0));
-          fromTranslation(this[PRIVATE$3].viewSpaces[XREye.Right][PRIVATE$l].offsetMatrix, fromValues$2(ipd / 2, 0, 0));
+          fromTranslation(this[P_ACTION_PLAYER].viewSpaces[XREye.Left][P_SPACE].offsetMatrix, fromValues$2(-ipd / 2, 0, 0));
+          fromTranslation(this[P_ACTION_PLAYER].viewSpaces[XREye.Right][P_SPACE].offsetMatrix, fromValues$2(ipd / 2, 0, 0));
           schema.forEach((schemaEntry) => {
               const index = schemaEntry[0];
               const schema = schemaEntry[1];
@@ -3892,53 +4459,55 @@
                   });
               }
               const inputSource = new XRInputSource(schema.handedness, schema.targetRayMode, schema.profiles, targetRaySpace, gamepad, schema.hasGrip ? new XRSpace(refSpace) : undefined, schema.hasHand ? hand : undefined);
-              this[PRIVATE$3].inputSources.set(index, {
+              this[P_ACTION_PLAYER].inputSources.set(index, {
                   active: false,
                   source: inputSource,
               });
-              this[PRIVATE$3].inputSchemas.set(index, schema);
+              this[P_ACTION_PLAYER].inputSchemas.set(index, schema);
           });
       }
       play() {
-          this[PRIVATE$3].recordedFramePointer = 0;
-          this[PRIVATE$3].playbackTime = this[PRIVATE$3].startingTimeStamp;
-          this[PRIVATE$3].playing = true;
-          this[PRIVATE$3].actualTimeStamp = performance.now();
+          this[P_ACTION_PLAYER].recordedFramePointer = 0;
+          this[P_ACTION_PLAYER].playbackTime =
+              this[P_ACTION_PLAYER].startingTimeStamp;
+          this[P_ACTION_PLAYER].playing = true;
+          this[P_ACTION_PLAYER].actualTimeStamp = performance.now();
       }
       stop() {
-          this[PRIVATE$3].playing = false;
+          this[P_ACTION_PLAYER].playing = false;
       }
       get playing() {
-          return this[PRIVATE$3].playing;
+          return this[P_ACTION_PLAYER].playing;
       }
       get viewerSpace() {
-          return this[PRIVATE$3].viewerSpace;
+          return this[P_ACTION_PLAYER].viewerSpace;
       }
       get viewSpaces() {
-          return this[PRIVATE$3].viewSpaces;
+          return this[P_ACTION_PLAYER].viewSpaces;
       }
       get inputSources() {
-          return Array.from(this[PRIVATE$3].inputSources.values())
+          return Array.from(this[P_ACTION_PLAYER].inputSources.values())
               .filter((wrapper) => wrapper.active)
               .map((wrapper) => wrapper.source);
       }
       playFrame() {
           const now = performance.now();
-          const delta = now - this[PRIVATE$3].actualTimeStamp;
-          this[PRIVATE$3].actualTimeStamp = now;
-          this[PRIVATE$3].playbackTime += delta;
-          if (this[PRIVATE$3].playbackTime > this[PRIVATE$3].endingTimeStamp) {
+          const delta = now - this[P_ACTION_PLAYER].actualTimeStamp;
+          this[P_ACTION_PLAYER].actualTimeStamp = now;
+          this[P_ACTION_PLAYER].playbackTime += delta;
+          if (this[P_ACTION_PLAYER].playbackTime >
+              this[P_ACTION_PLAYER].endingTimeStamp) {
               this.stop();
               return;
           }
-          while (this[PRIVATE$3].frames[this[PRIVATE$3].recordedFramePointer + 1][0] < this[PRIVATE$3].playbackTime) {
-              this[PRIVATE$3].recordedFramePointer++;
+          while (this[P_ACTION_PLAYER].frames[this[P_ACTION_PLAYER].recordedFramePointer + 1][0] < this[P_ACTION_PLAYER].playbackTime) {
+              this[P_ACTION_PLAYER].recordedFramePointer++;
           }
-          const lastFrameData = this[PRIVATE$3].frames[this[PRIVATE$3].recordedFramePointer];
-          const nextFrameData = this[PRIVATE$3].frames[this[PRIVATE$3].recordedFramePointer + 1];
-          const alpha = (this[PRIVATE$3].playbackTime - lastFrameData[0]) /
+          const lastFrameData = this[P_ACTION_PLAYER].frames[this[P_ACTION_PLAYER].recordedFramePointer];
+          const nextFrameData = this[P_ACTION_PLAYER].frames[this[P_ACTION_PLAYER].recordedFramePointer + 1];
+          const alpha = (this[P_ACTION_PLAYER].playbackTime - lastFrameData[0]) /
               (nextFrameData[0] - lastFrameData[0]);
-          this.updateXRSpaceFromMergedFrames(this[PRIVATE$3].viewerSpace, lastFrameData.slice(1, 8), nextFrameData.slice(1, 8), alpha);
+          this.updateXRSpaceFromMergedFrames(this[P_ACTION_PLAYER].viewerSpace, lastFrameData.slice(1, 8), nextFrameData.slice(1, 8), alpha);
           const lastFrameInputs = new Map();
           for (let i = 8; i < lastFrameData.length; i++) {
               const { index, inputData } = this.processRawInputData(lastFrameData[i]);
@@ -3949,13 +4518,13 @@
               const { index, inputData } = this.processRawInputData(nextFrameData[i]);
               nextFrameInputs.set(index, inputData);
           }
-          this[PRIVATE$3].inputSources.forEach((sourceWrapper) => {
+          this[P_ACTION_PLAYER].inputSources.forEach((sourceWrapper) => {
               sourceWrapper.active = false;
           });
           nextFrameInputs.forEach((inputData, index) => {
-              this[PRIVATE$3].inputSources.get(index).active = true;
-              const inputSource = this[PRIVATE$3].inputSources.get(index).source;
-              const schema = this[PRIVATE$3].inputSchemas.get(index);
+              this[P_ACTION_PLAYER].inputSources.get(index).active = true;
+              const inputSource = this[P_ACTION_PLAYER].inputSources.get(index).source;
+              const schema = this[P_ACTION_PLAYER].inputSchemas.get(index);
               this.updateInputSource(inputSource, schema, lastFrameInputs.has(index) ? lastFrameInputs.get(index) : inputData, inputData, alpha);
           });
       }
@@ -3972,7 +4541,7 @@
                   const nextRadius = nextInputData.handTransforms[i * 8 + 7];
                   const jointSpace = inputSource.hand.get(schema.jointSequence[i]);
                   this.updateXRSpaceFromMergedFrames(jointSpace, lastTransformArray, nextTransformArray, alpha);
-                  jointSpace[PRIVATE$f].radius =
+                  jointSpace[P_JOINT_SPACE].radius =
                       (nextRadius - lastRadius) * alpha + lastRadius;
               }
           }
@@ -3980,16 +4549,16 @@
               const gamepad = inputSource.gamepad;
               nextInputData.buttons.forEach((states, index) => {
                   const gamepadButton = gamepad.buttons[index];
-                  gamepadButton[PRIVATE$k].pressed = states[0] === 1 ? true : false;
-                  gamepadButton[PRIVATE$k].touched = states[1] === 1 ? true : false;
+                  gamepadButton[P_GAMEPAD].pressed = states[0] === 1 ? true : false;
+                  gamepadButton[P_GAMEPAD].touched = states[1] === 1 ? true : false;
                   const lastValue = lastInputData.buttons[index][2];
                   const nextValue = states[2];
-                  gamepadButton[PRIVATE$k].value =
+                  gamepadButton[P_GAMEPAD].value =
                       (nextValue - lastValue) * alpha + lastValue;
               });
               nextInputData.axes.forEach((nextValue, index) => {
                   const lastValue = lastInputData.axes[index];
-                  gamepad[PRIVATE$k].axesMap[index.toString()].x =
+                  gamepad[P_GAMEPAD].axesMap[index.toString()].x =
                       (nextValue - lastValue) * alpha + lastValue;
               });
           }
@@ -3999,13 +4568,13 @@
           const f1q = fromValues(lastTransform[3], lastTransform[4], lastTransform[5], lastTransform[6]);
           const f2p = fromValues$2(nextTransform[0], nextTransform[1], nextTransform[2]);
           const f2q = fromValues(nextTransform[3], nextTransform[4], nextTransform[5], nextTransform[6]);
-          lerp(this[PRIVATE$3].vec3, f1p, f2p, alpha);
-          slerp(this[PRIVATE$3].quat, f1q, f2q, alpha);
-          fromRotationTranslation(space[PRIVATE$l].offsetMatrix, this[PRIVATE$3].quat, this[PRIVATE$3].vec3);
+          lerp(this[P_ACTION_PLAYER].vec3, f1p, f2p, alpha);
+          slerp(this[P_ACTION_PLAYER].quat, f1q, f2q, alpha);
+          fromRotationTranslation(space[P_SPACE].offsetMatrix, this[P_ACTION_PLAYER].quat, this[P_ACTION_PLAYER].vec3);
       }
       processRawInputData(inputDataRaw) {
           const index = inputDataRaw[0];
-          const schema = this[PRIVATE$3].inputSchemas.get(index);
+          const schema = this[P_ACTION_PLAYER].inputSchemas.get(index);
           const targetRayTransform = inputDataRaw.slice(1, 8);
           const inputData = { targetRayTransform };
           let dataCounter = 8;
@@ -4024,7 +4593,7 @@
       }
   }
 
-  const VERSION = "1.0.4";
+  const VERSION = "1.1.0";
 
   /**
    * Copyright (c) Meta Platforms, Inc. and affiliates.
@@ -4049,22 +4618,89 @@
    * This source code is licensed under the MIT license found in the
    * LICENSE file in the root directory of this source tree.
    */
-  const PRIVATE$2 = Symbol('@immersive-web-emulation-runtime/xr-viewport');
+  class XRSystem extends EventTarget {
+      constructor(device) {
+          super();
+          this[P_SYSTEM] = { device };
+          // Initialize device change monitoring here if applicable
+      }
+      isSessionSupported(mode) {
+          return new Promise((resolve, _reject) => {
+              if (mode === 'inline') {
+                  resolve(true);
+              }
+              else {
+                  // Check for spatial tracking permission if necessary
+                  resolve(this[P_SYSTEM].device.supportedSessionModes.includes(mode));
+              }
+          });
+      }
+      requestSession(mode, options = {}) {
+          return new Promise((resolve, reject) => {
+              this.isSessionSupported(mode)
+                  .then((isSupported) => {
+                  if (!isSupported) {
+                      reject(new DOMException('The requested XRSession mode is not supported.', 'NotSupportedError'));
+                      return;
+                  }
+                  // Check for active sessions and other constraints here
+                  if (this[P_SYSTEM].activeSession) {
+                      reject(new DOMException('An active XRSession already exists.', 'InvalidStateError'));
+                      return;
+                  }
+                  // Handle required and optional features
+                  const { requiredFeatures = [], optionalFeatures = [] } = options;
+                  const { supportedFeatures } = this[P_SYSTEM].device;
+                  // Check if all required features are supported
+                  const allRequiredSupported = requiredFeatures.every((feature) => supportedFeatures.includes(feature));
+                  if (!allRequiredSupported) {
+                      reject(new Error('One or more required features are not supported by the device.'));
+                      return;
+                  }
+                  // Filter out unsupported optional features
+                  const supportedOptionalFeatures = optionalFeatures.filter((feature) => supportedFeatures.includes(feature));
+                  // Combine required and supported optional features into enabled features
+                  const enabledFeatures = Array.from(new Set([
+                      ...requiredFeatures,
+                      ...supportedOptionalFeatures,
+                      'viewer',
+                      'local',
+                  ]));
+                  // Proceed with session creation
+                  const session = new XRSession(this[P_SYSTEM].device, mode, enabledFeatures);
+                  this[P_SYSTEM].activeSession = session;
+                  // Listen for session end to clear the active session
+                  session.addEventListener('end', () => {
+                      this[P_SYSTEM].activeSession = undefined;
+                  });
+                  resolve(session);
+              })
+                  .catch(reject);
+          });
+      }
+  }
+
+  /**
+   * Copyright (c) Meta Platforms, Inc. and affiliates.
+   *
+   * This source code is licensed under the MIT license found in the
+   * LICENSE file in the root directory of this source tree.
+   */
   class XRViewport {
       constructor(x, y, width, height) {
-          this[PRIVATE$2] = { x, y, width, height };
+          this[P_VIEWPORT] = { x, y, width, height };
       }
       get x() {
-          return this[PRIVATE$2].x;
+          return this[P_VIEWPORT].x;
       }
       get y() {
-          return this[PRIVATE$2].y;
+          return this[P_VIEWPORT].y;
       }
       get width() {
-          return this[PRIVATE$2].width;
+          return this[P_VIEWPORT].width;
       }
       get height() {
-          return this[PRIVATE$2].height;
+          return this[P_VIEWPORT].height;
       }
   }
 
@@ -4074,22 +4710,6 @@
    * This source code is licensed under the MIT license found in the
    * LICENSE file in the root directory of this source tree.
    */
-  var WebXRFeatures;
-  (function (WebXRFeatures) {
-      WebXRFeatures["Viewer"] = "viewer";
-      WebXRFeatures["Local"] = "local";
-      WebXRFeatures["LocalFloor"] = "local-floor";
-      WebXRFeatures["BoundedFloor"] = "bounded-floor";
-      WebXRFeatures["Unbounded"] = "unbounded";
-      WebXRFeatures["DomOverlay"] = "dom-overlay";
-      WebXRFeatures["Anchors"] = "anchors";
-      WebXRFeatures["PlaneDetection"] = "plane-detection";
-      WebXRFeatures["MeshDetection"] = "mesh-detection";
-      WebXRFeatures["HitTest"] = "hit-test";
-      WebXRFeatures["HandTracking"] = "hand-tracking";
-      WebXRFeatures["DepthSensing"] = "depth-sensing";
-  })(WebXRFeatures || (WebXRFeatures = {}));
-  const PRIVATE$1 = Symbol('@immersive-web-emulation-runtime/xr-device');
   const DEFAULTS = {
       ipd: 0.063,
       fovy: Math.PI / 2,
@@ -4136,7 +4756,7 @@
           canvasContainer.style.alignItems = 'center';
           canvasContainer.style.overflow = 'hidden';
           canvasContainer.style.zIndex = '999';
-          this[PRIVATE$1] = {
+          this[P_DEVICE] = {
               name: deviceConfig.name,
               supportedSessionModes: deviceConfig.supportedSessionModes,
               supportedFeatures: deviceConfig.supportedFeatures,
@@ -4155,7 +4775,7 @@
               hands,
               primaryInputMode: 'controller',
               pendingReferenceSpaceReset: false,
-              visibilityState: XRVisibilityState.Visible,
+              visibilityState: 'visible',
               pendingVisibilityState: null,
               xrSystem: null,
               matrix: create$3(),
@@ -4170,74 +4790,74 @@
                       case XREye.None:
                           return new XRViewport(0, 0, width, height);
                       case XREye.Left:
-                          return new XRViewport(0, 0, this[PRIVATE$1].stereoEnabled ? width / 2 : width, height);
+                          return new XRViewport(0, 0, this[P_DEVICE].stereoEnabled ? width / 2 : width, height);
                       case XREye.Right:
-                          return new XRViewport(width / 2, 0, this[PRIVATE$1].stereoEnabled ? width / 2 : 0, height);
+                          return new XRViewport(width / 2, 0, this[P_DEVICE].stereoEnabled ? width / 2 : 0, height);
                   }
               },
               updateViews: () => {
                   // update viewerSpace
-                  const viewerSpace = this[PRIVATE$1].viewerSpace;
-                  fromRotationTranslation(viewerSpace[PRIVATE$l].offsetMatrix, this[PRIVATE$1].quaternion.quat, this[PRIVATE$1].position.vec3);
+                  const viewerSpace = this[P_DEVICE].viewerSpace;
+                  fromRotationTranslation(viewerSpace[P_SPACE].offsetMatrix, this[P_DEVICE].quaternion.quat, this[P_DEVICE].position.vec3);
                   // update viewSpaces
-                  fromTranslation(this[PRIVATE$1].viewSpaces[XREye.Left][PRIVATE$l].offsetMatrix, fromValues$2(-this[PRIVATE$1].ipd / 2, 0, 0));
-                  fromTranslation(this[PRIVATE$1].viewSpaces[XREye.Right][PRIVATE$l].offsetMatrix, fromValues$2(this[PRIVATE$1].ipd / 2, 0, 0));
+                  fromTranslation(this[P_DEVICE].viewSpaces[XREye.Left][P_SPACE].offsetMatrix, fromValues$2(-this[P_DEVICE].ipd / 2, 0, 0));
+                  fromTranslation(this[P_DEVICE].viewSpaces[XREye.Right][P_SPACE].offsetMatrix, fromValues$2(this[P_DEVICE].ipd / 2, 0, 0));
               },
               onBaseLayerSet: (baseLayer) => {
                   if (!baseLayer)
                       return;
                   // backup canvas data
                   const canvas = baseLayer.context.canvas;
-                  if (canvas.parentElement !== this[PRIVATE$1].canvasContainer) {
-                      this[PRIVATE$1].canvasData = {
+                  if (canvas.parentElement !== this[P_DEVICE].canvasContainer) {
+                      this[P_DEVICE].canvasData = {
                           canvas,
                           parent: canvas.parentElement,
                           width: canvas.width,
                           height: canvas.height,
                       };
-                      this[PRIVATE$1].canvasContainer.appendChild(canvas);
-                      document.body.appendChild(this[PRIVATE$1].canvasContainer);
+                      this[P_DEVICE].canvasContainer.appendChild(canvas);
+                      document.body.appendChild(this[P_DEVICE].canvasContainer);
                   }
                   canvas.width = window.innerWidth;
                   canvas.height = window.innerHeight;
               },
               onSessionEnd: () => {
-                  if (this[PRIVATE$1].canvasData) {
-                      const { canvas, parent, width, height } = this[PRIVATE$1].canvasData;
+                  if (this[P_DEVICE].canvasData) {
+                      const { canvas, parent, width, height } = this[P_DEVICE].canvasData;
                       canvas.width = width;
                       canvas.height = height;
                       if (parent) {
                           parent.appendChild(canvas);
                       }
                       else {
-                          this[PRIVATE$1].canvasContainer.removeChild(canvas);
+                          this[P_DEVICE].canvasContainer.removeChild(canvas);
                       }
-                      document.body.removeChild(this[PRIVATE$1].canvasContainer);
+                      document.body.removeChild(this[P_DEVICE].canvasContainer);
                       window.dispatchEvent(new Event('resize'));
                   }
               },
               onFrameStart: (frame) => {
                   var _a;
-                  if ((_a = this[PRIVATE$1].actionPlayer) === null || _a === void 0 ? void 0 : _a.playing) {
-                      this[PRIVATE$1].actionPlayer.playFrame();
+                  if ((_a = this[P_DEVICE].actionPlayer) === null || _a === void 0 ? void 0 : _a.playing) {
+                      this[P_DEVICE].actionPlayer.playFrame();
                   }
                   else {
                       const session = frame.session;
-                      this[PRIVATE$1].updateViews();
-                      if (this[PRIVATE$1].pendingVisibilityState) {
-                          this[PRIVATE$1].visibilityState =
-                              this[PRIVATE$1].pendingVisibilityState;
-                          this[PRIVATE$1].pendingVisibilityState = null;
+                      this[P_DEVICE].updateViews();
+                      if (this[P_DEVICE].pendingVisibilityState) {
+                          this[P_DEVICE].visibilityState =
+                              this[P_DEVICE].pendingVisibilityState;
+                          this[P_DEVICE].pendingVisibilityState = null;
                           session.dispatchEvent(new XRSessionEvent('visibilitychange', { session }));
                       }
-                      if (this[PRIVATE$1].visibilityState === XRVisibilityState.Visible) {
+                      if (this[P_DEVICE].visibilityState === 'visible') {
                           this.activeInputs.forEach((activeInput) => {
                               activeInput.onFrameStart(frame);
                           });
                       }
-                      if (this[PRIVATE$1].pendingReferenceSpaceReset) {
-                          session[PRIVATE$6].referenceSpaces.forEach((referenceSpace) => {
-                              switch (referenceSpace[PRIVATE$9].type) {
+                      if (this[P_DEVICE].pendingReferenceSpaceReset) {
+                          session[P_SESSION].referenceSpaces.forEach((referenceSpace) => {
+                              switch (referenceSpace[P_REF_SPACE].type) {
                                   case XRReferenceSpaceType.Local:
                                   case XRReferenceSpaceType.LocalFloor:
                                   case XRReferenceSpaceType.BoundedFloor:
@@ -4246,13 +4866,13 @@
                                       break;
                               }
                           });
-                          this[PRIVATE$1].pendingReferenceSpaceReset = false;
+                          this[P_DEVICE].pendingReferenceSpaceReset = false;
                       }
                   }
-                  this[PRIVATE$1].updateViews();
+                  this[P_DEVICE].updateViews();
               },
           };
-          this[PRIVATE$1].updateViews();
+          this[P_DEVICE].updateViews();
       }
       installRuntime(globalObject = globalThis) {
           Object.defineProperty(WebGL2RenderingContext.prototype, 'makeXRCompatible', {
@@ -4263,13 +4883,13 @@
               },
               configurable: true,
           });
-          this[PRIVATE$1].xrSystem = new XRSystem(this);
+          this[P_DEVICE].xrSystem = new XRSystem(this);
           Object.defineProperty(globalThis.navigator, 'xr', {
-              value: this[PRIVATE$1].xrSystem,
+              value: this[P_DEVICE].xrSystem,
               configurable: true,
           });
           Object.defineProperty(navigator, 'userAgent', {
-              value: this[PRIVATE$1].userAgent,
+              value: this[P_DEVICE].userAgent,
               writable: false,
               configurable: false,
               enumerable: true,
@@ -4297,103 +4917,106 @@
           globalObject['XRInputSourcesChangeEvent'] = XRInputSourcesChangeEvent;
           globalObject['XRReferenceSpaceEvent'] = XRReferenceSpaceEvent;
       }
+      installSyntheticEnvironmentModule(sem) {
+          this[P_DEVICE].syntheticEnvironmentModule = sem;
+      }
       get supportedSessionModes() {
-          return this[PRIVATE$1].supportedSessionModes;
+          return this[P_DEVICE].supportedSessionModes;
       }
       get supportedFeatures() {
-          return this[PRIVATE$1].supportedFeatures;
+          return this[P_DEVICE].supportedFeatures;
       }
       get supportedFrameRates() {
-          return this[PRIVATE$1].supportedFrameRates;
+          return this[P_DEVICE].supportedFrameRates;
       }
       get isSystemKeyboardSupported() {
-          return this[PRIVATE$1].isSystemKeyboardSupported;
+          return this[P_DEVICE].isSystemKeyboardSupported;
       }
       get internalNominalFrameRate() {
-          return this[PRIVATE$1].internalNominalFrameRate;
+          return this[P_DEVICE].internalNominalFrameRate;
       }
       get stereoEnabled() {
-          return this[PRIVATE$1].stereoEnabled;
+          return this[P_DEVICE].stereoEnabled;
       }
       set stereoEnabled(value) {
-          this[PRIVATE$1].stereoEnabled = value;
+          this[P_DEVICE].stereoEnabled = value;
       }
       get ipd() {
-          return this[PRIVATE$1].ipd;
+          return this[P_DEVICE].ipd;
       }
       set ipd(value) {
-          this[PRIVATE$1].ipd = value;
+          this[P_DEVICE].ipd = value;
       }
       get fovy() {
-          return this[PRIVATE$1].fovy;
+          return this[P_DEVICE].fovy;
       }
       set fovy(value) {
-          this[PRIVATE$1].fovy = value;
+          this[P_DEVICE].fovy = value;
       }
       get position() {
-          return this[PRIVATE$1].position;
+          return this[P_DEVICE].position;
       }
       get quaternion() {
-          return this[PRIVATE$1].quaternion;
+          return this[P_DEVICE].quaternion;
       }
       get viewerSpace() {
           var _a;
-          if ((_a = this[PRIVATE$1].actionPlayer) === null || _a === void 0 ? void 0 : _a.playing) {
-              return this[PRIVATE$1].actionPlayer.viewerSpace;
+          if ((_a = this[P_DEVICE].actionPlayer) === null || _a === void 0 ? void 0 : _a.playing) {
+              return this[P_DEVICE].actionPlayer.viewerSpace;
           }
           else {
-              return this[PRIVATE$1].viewerSpace;
+              return this[P_DEVICE].viewerSpace;
           }
       }
       get viewSpaces() {
           var _a;
-          if ((_a = this[PRIVATE$1].actionPlayer) === null || _a === void 0 ? void 0 : _a.playing) {
-              return this[PRIVATE$1].actionPlayer.viewSpaces;
+          if ((_a = this[P_DEVICE].actionPlayer) === null || _a === void 0 ? void 0 : _a.playing) {
+              return this[P_DEVICE].actionPlayer.viewSpaces;
           }
           else {
-              return this[PRIVATE$1].viewSpaces;
+              return this[P_DEVICE].viewSpaces;
           }
       }
       get controllers() {
-          return this[PRIVATE$1].controllers;
+          return this[P_DEVICE].controllers;
       }
       get hands() {
-          return this[PRIVATE$1].hands;
+          return this[P_DEVICE].hands;
       }
       get primaryInputMode() {
-          return this[PRIVATE$1].primaryInputMode;
+          return this[P_DEVICE].primaryInputMode;
       }
       set primaryInputMode(mode) {
           if (mode !== 'controller' && mode !== 'hand') {
               console.warn('primary input mode can only be "controller" or "hand"');
               return;
           }
-          this[PRIVATE$1].primaryInputMode = mode;
+          this[P_DEVICE].primaryInputMode = mode;
       }
       get activeInputs() {
-          if (this[PRIVATE$1].visibilityState !== XRVisibilityState.Visible) {
+          if (this[P_DEVICE].visibilityState !== 'visible') {
               return [];
           }
-          const activeInputs = this[PRIVATE$1].primaryInputMode === 'controller'
-              ? Object.values(this[PRIVATE$1].controllers)
-              : Object.values(this[PRIVATE$1].hands);
+          const activeInputs = this[P_DEVICE].primaryInputMode === 'controller'
+              ? Object.values(this[P_DEVICE].controllers)
+              : Object.values(this[P_DEVICE].hands);
           return activeInputs.filter((input) => input.connected);
       }
       get inputSources() {
           var _a;
-          if ((_a = this[PRIVATE$1].actionPlayer) === null || _a === void 0 ? void 0 : _a.playing) {
-              return this[PRIVATE$1].actionPlayer.inputSources;
+          if ((_a = this[P_DEVICE].actionPlayer) === null || _a === void 0 ? void 0 : _a.playing) {
+              return this[P_DEVICE].actionPlayer.inputSources;
           }
           else {
               return this.activeInputs.map((input) => input.inputSource);
           }
       }
       get canvasContainer() {
-          return this[PRIVATE$1].canvasContainer;
+          return this[P_DEVICE].canvasContainer;
       }
       get activeSession() {
           var _a;
-          return (_a = this[PRIVATE$1].xrSystem) === null || _a === void 0 ? void 0 : _a[PRIVATE$4].activeSession;
+          return (_a = this[P_DEVICE].xrSystem) === null || _a === void 0 ? void 0 : _a[P_SYSTEM].activeSession;
       }
       recenter() {
           const deltaVec = new Vector3(-this.position.x, 0, -this.position.z);
@@ -4405,30 +5028,30 @@
           this.position.add(deltaVec);
           this.quaternion.multiply(deltaQuat);
           [
-              ...Object.values(this[PRIVATE$1].controllers),
-              ...Object.values(this[PRIVATE$1].hands),
+              ...Object.values(this[P_DEVICE].controllers),
+              ...Object.values(this[P_DEVICE].hands),
           ].forEach((activeInput) => {
               activeInput.position.add(deltaVec);
               activeInput.quaternion.multiply(deltaQuat);
               activeInput.position.applyQuaternion(deltaQuat);
           });
-          this[PRIVATE$1].pendingReferenceSpaceReset = true;
+          this[P_DEVICE].pendingReferenceSpaceReset = true;
       }
       get visibilityState() {
-          return this[PRIVATE$1].visibilityState;
+          return this[P_DEVICE].visibilityState;
       }
       // visibility state updates are queued until the XRSession produces frames
       updateVisibilityState(state) {
-          if (!Object.values(XRVisibilityState).includes(state)) {
+          if (!Object.values(['visible', 'visible-blurred', 'hidden']).includes(state)) {
               throw new DOMException('Invalid XRVisibilityState value', 'NotSupportedError');
           }
-          if (state !== this[PRIVATE$1].visibilityState) {
-              this[PRIVATE$1].pendingVisibilityState = state;
+          if (state !== this[P_DEVICE].visibilityState) {
+              this[P_DEVICE].pendingVisibilityState = state;
           }
       }
       createActionPlayer(refSpace, recording) {
-          this[PRIVATE$1].actionPlayer = new ActionPlayer(refSpace, recording, this[PRIVATE$1].ipd);
-          return this[PRIVATE$1].actionPlayer;
+          this[P_DEVICE].actionPlayer = new ActionPlayer(refSpace, recording, this[P_DEVICE].ipd);
+          return this[P_DEVICE].actionPlayer;
       }
   }
 
@@ -4596,27 +5219,23 @@
   const oculusQuest1 = {
       name: 'Oculus Quest 1',
       controllerConfig: oculusTouchV2,
-      supportedSessionModes: [
-          XRSessionMode.Inline,
-          XRSessionMode.ImmersiveVR,
-          XRSessionMode.ImmersiveAR,
-      ],
+      supportedSessionModes: ['inline', 'immersive-vr', 'immersive-ar'],
       supportedFeatures: [
-          WebXRFeatures.Viewer,
-          WebXRFeatures.Local,
-          WebXRFeatures.LocalFloor,
-          WebXRFeatures.BoundedFloor,
-          WebXRFeatures.Unbounded,
-          WebXRFeatures.Anchors,
-          WebXRFeatures.PlaneDetection,
-          WebXRFeatures.HandTracking,
+          'viewer',
+          'local',
+          'local-floor',
+          'bounded-floor',
+          'unbounded',
+          'anchors',
+          'plane-detection',
+          'hand-tracking',
       ],
       supportedFrameRates: [72, 80, 90],
       isSystemKeyboardSupported: true,
       internalNominalFrameRate: 72,
       environmentBlendModes: {
-          [XRSessionMode.ImmersiveVR]: XREnvironmentBlendMode.Opaque,
-          [XRSessionMode.ImmersiveAR]: XREnvironmentBlendMode.AlphaBlend,
+          ['immersive-vr']: XREnvironmentBlendMode.Opaque,
+          ['immersive-ar']: XREnvironmentBlendMode.AlphaBlend,
       },
       interactionMode: XRInteractionMode.WorldSpace,
       userAgent: 'Mozilla/5.0 (X11; Linux x86_64; Quest 1) AppleWebKit/537.36 (KHTML, like Gecko) OculusBrowser/33.0.0.x.x.x Chrome/126.0.6478.122 VR Safari/537.36',
@@ -4624,29 +5243,25 @@
   const metaQuest2 = {
       name: 'Meta Quest 2',
       controllerConfig: oculusTouchV3,
-      supportedSessionModes: [
-          XRSessionMode.Inline,
-          XRSessionMode.ImmersiveVR,
-          XRSessionMode.ImmersiveAR,
-      ],
+      supportedSessionModes: ['inline', 'immersive-vr', 'immersive-ar'],
       supportedFeatures: [
-          WebXRFeatures.Viewer,
-          WebXRFeatures.Local,
-          WebXRFeatures.LocalFloor,
-          WebXRFeatures.BoundedFloor,
-          WebXRFeatures.Unbounded,
-          WebXRFeatures.Anchors,
-          WebXRFeatures.PlaneDetection,
-          WebXRFeatures.MeshDetection,
-          WebXRFeatures.HitTest,
-          WebXRFeatures.HandTracking,
+          'viewer',
+          'local',
+          'local-floor',
+          'bounded-floor',
+          'unbounded',
+          'anchors',
+          'plane-detection',
+          'mesh-detection',
+          'hit-test',
+          'hand-tracking',
       ],
       supportedFrameRates: [72, 80, 90, 120],
       isSystemKeyboardSupported: true,
       internalNominalFrameRate: 72,
       environmentBlendModes: {
-          [XRSessionMode.ImmersiveVR]: XREnvironmentBlendMode.Opaque,
-          [XRSessionMode.ImmersiveAR]: XREnvironmentBlendMode.AlphaBlend,
+          ['immersive-vr']: XREnvironmentBlendMode.Opaque,
+          ['immersive-ar']: XREnvironmentBlendMode.AlphaBlend,
       },
       interactionMode: XRInteractionMode.WorldSpace,
       userAgent: 'Mozilla/5.0 (X11; Linux x86_64; Quest 2) AppleWebKit/537.36 (KHTML, like Gecko) OculusBrowser/33.0.0.x.x.x Chrome/126.0.6478.122 VR Safari/537.36',
@@ -4654,29 +5269,25 @@
   const metaQuestPro = {
       name: 'Meta Quest Pro',
       controllerConfig: metaQuestTouchPro,
-      supportedSessionModes: [
-          XRSessionMode.Inline,
-          XRSessionMode.ImmersiveVR,
-          XRSessionMode.ImmersiveAR,
-      ],
+      supportedSessionModes: ['inline', 'immersive-vr', 'immersive-ar'],
       supportedFeatures: [
-          WebXRFeatures.Viewer,
-          WebXRFeatures.Local,
-          WebXRFeatures.LocalFloor,
-          WebXRFeatures.BoundedFloor,
-          WebXRFeatures.Unbounded,
-          WebXRFeatures.Anchors,
-          WebXRFeatures.PlaneDetection,
-          WebXRFeatures.MeshDetection,
-          WebXRFeatures.HitTest,
-          WebXRFeatures.HandTracking,
+          'viewer',
+          'local',
+          'local-floor',
+          'bounded-floor',
+          'unbounded',
+          'anchors',
+          'plane-detection',
+          'mesh-detection',
+          'hit-test',
+          'hand-tracking',
       ],
       supportedFrameRates: [72, 80, 90, 120],
       isSystemKeyboardSupported: true,
       internalNominalFrameRate: 90,
       environmentBlendModes: {
-          [XRSessionMode.ImmersiveVR]: XREnvironmentBlendMode.Opaque,
-          [XRSessionMode.ImmersiveAR]: XREnvironmentBlendMode.AlphaBlend,
+          ['immersive-vr']: XREnvironmentBlendMode.Opaque,
+          ['immersive-ar']: XREnvironmentBlendMode.AlphaBlend,
       },
       interactionMode: XRInteractionMode.WorldSpace,
       userAgent: 'Mozilla/5.0 (X11; Linux x86_64; Quest Pro) AppleWebKit/537.36 (KHTML, like Gecko) OculusBrowser/33.0.0.x.x.x Chrome/126.0.6478.122 VR Safari/537.36',
@@ -4684,30 +5295,26 @@
   const metaQuest3 = {
       name: 'Meta Quest 3',
       controllerConfig: metaQuestTouchPlus,
-      supportedSessionModes: [
-          XRSessionMode.Inline,
-          XRSessionMode.ImmersiveVR,
-          XRSessionMode.ImmersiveAR,
-      ],
+      supportedSessionModes: ['inline', 'immersive-vr', 'immersive-ar'],
       supportedFeatures: [
-          WebXRFeatures.Viewer,
-          WebXRFeatures.Local,
-          WebXRFeatures.LocalFloor,
-          WebXRFeatures.BoundedFloor,
-          WebXRFeatures.Unbounded,
-          WebXRFeatures.Anchors,
-          WebXRFeatures.PlaneDetection,
-          WebXRFeatures.MeshDetection,
-          WebXRFeatures.HitTest,
-          WebXRFeatures.HandTracking,
-          WebXRFeatures.DepthSensing,
+          'viewer',
+          'local',
+          'local-floor',
+          'bounded-floor',
+          'unbounded',
+          'anchors',
+          'plane-detection',
+          'mesh-detection',
+          'hit-test',
+          'hand-tracking',
+          'depth-sensing',
       ],
       supportedFrameRates: [72, 80, 90, 120],
       isSystemKeyboardSupported: true,
       internalNominalFrameRate: 90,
       environmentBlendModes: {
-          [XRSessionMode.ImmersiveVR]: XREnvironmentBlendMode.Opaque,
-          [XRSessionMode.ImmersiveAR]: XREnvironmentBlendMode.AlphaBlend,
+          ['immersive-vr']: XREnvironmentBlendMode.Opaque,
+          ['immersive-ar']: XREnvironmentBlendMode.AlphaBlend,
       },
       interactionMode: XRInteractionMode.WorldSpace,
       userAgent: 'Mozilla/5.0 (X11; Linux x86_64; Quest 3) AppleWebKit/537.36 (KHTML, like Gecko) OculusBrowser/33.0.0.x.x.x Chrome/126.0.6478.122 VR Safari/537.36',
@@ -4719,7 +5326,6 @@
    * This source code is licensed under the MIT license found in the
    * LICENSE file in the root directory of this source tree.
    */
-  const PRIVATE = Symbol('@immersive-web-emulation-runtime/action-recorder');
   const compress = (arr) => {
       const out = [];
       arr.forEach((num) => {
@@ -4729,7 +5335,7 @@
   };
   class ActionRecorder {
       constructor(session, refSpace) {
-          this[PRIVATE] = {
+          this[P_ACTION_RECORDER] = {
               session,
               refSpace,
               inputMap: new Map(),
@@ -4742,7 +5348,7 @@
       recordFrame(frame) {
           var _a;
           const timeStamp = performance.now();
-          const viewerMatrix = (_a = frame.getViewerPose(this[PRIVATE].refSpace)) === null || _a === void 0 ? void 0 : _a.transform.matrix;
+          const viewerMatrix = (_a = frame.getViewerPose(this[P_ACTION_RECORDER].refSpace)) === null || _a === void 0 ? void 0 : _a.transform.matrix;
           if (!viewerMatrix)
               return;
           const position = getTranslation(create$2(), viewerMatrix);
@@ -4753,9 +5359,9 @@
               quaternion,
               inputFrames: [],
           };
-          this[PRIVATE].session.inputSources.forEach((inputSource) => {
+          this[P_ACTION_RECORDER].session.inputSources.forEach((inputSource) => {
               var _a, _b;
-              if (!this[PRIVATE].inputMap.has(inputSource)) {
+              if (!this[P_ACTION_RECORDER].inputMap.has(inputSource)) {
                   const schema = {
                       handedness: inputSource.handedness,
                       targetRayMode: inputSource.targetRayMode,
@@ -4772,13 +5378,13 @@
                       schema.numButtons = inputSource.gamepad.buttons.length;
                       schema.numAxes = inputSource.gamepad.axes.length;
                   }
-                  const index = this[PRIVATE].inputMap.size;
-                  this[PRIVATE].inputMap.set(inputSource, index);
-                  this[PRIVATE].schemaMap.set(index, schema);
+                  const index = this[P_ACTION_RECORDER].inputMap.size;
+                  this[P_ACTION_RECORDER].inputMap.set(inputSource, index);
+                  this[P_ACTION_RECORDER].schemaMap.set(index, schema);
               }
-              const index = this[PRIVATE].inputMap.get(inputSource);
-              const schema = this[PRIVATE].schemaMap.get(index);
-              const targetRayMatrix = (_a = frame.getPose(inputSource.targetRaySpace, this[PRIVATE].refSpace)) === null || _a === void 0 ? void 0 : _a.transform.matrix;
+              const index = this[P_ACTION_RECORDER].inputMap.get(inputSource);
+              const schema = this[P_ACTION_RECORDER].schemaMap.get(index);
+              const targetRayMatrix = (_a = frame.getPose(inputSource.targetRaySpace, this[P_ACTION_RECORDER].refSpace)) === null || _a === void 0 ? void 0 : _a.transform.matrix;
               if (targetRayMatrix) {
                   const targetRayPosition = getTranslation(create$2(), targetRayMatrix);
                   const targetRayQuaternion = getRotation(create(), targetRayMatrix);
@@ -4790,7 +5396,7 @@
                       },
                   };
                   if (schema.hasGrip) {
-                      const gripMatrix = (_b = frame.getPose(inputSource.gripSpace, this[PRIVATE].refSpace)) === null || _b === void 0 ? void 0 : _b.transform.matrix;
+                      const gripMatrix = (_b = frame.getPose(inputSource.gripSpace, this[P_ACTION_RECORDER].refSpace)) === null || _b === void 0 ? void 0 : _b.transform.matrix;
                       if (gripMatrix) {
                           const position = getTranslation(create$2(), gripMatrix);
                           const quaternion = getRotation(create(), gripMatrix);
@@ -4804,14 +5410,14 @@
                       const jointSpaces = Array.from(inputSource.hand.values());
                       let allValid = true;
                       // @ts-ignore
-                      allValid && (allValid = frame.fillPoses(jointSpaces, inputSource.targetRaySpace, this[PRIVATE].jointTransforms));
+                      allValid && (allValid = frame.fillPoses(jointSpaces, inputSource.targetRaySpace, this[P_ACTION_RECORDER].jointTransforms));
                       // @ts-ignore
-                      allValid && (allValid = frame.fillJointRadii(jointSpaces, this[PRIVATE].jointRadii));
+                      allValid && (allValid = frame.fillJointRadii(jointSpaces, this[P_ACTION_RECORDER].jointRadii));
                       if (allValid) {
                           const hand = {};
                           for (let offset = 0; offset < 25; offset++) {
-                              const jointMatrix = this[PRIVATE].jointTransforms.slice(offset * 16, (offset + 1) * 16);
-                              const radius = this[PRIVATE].jointRadii[offset];
+                              const jointMatrix = this[P_ACTION_RECORDER].jointTransforms.slice(offset * 16, (offset + 1) * 16);
+                              const radius = this[P_ACTION_RECORDER].jointRadii[offset];
                               const position = getTranslation(create$2(), jointMatrix);
                               const quaternion = getRotation(create(), jointMatrix);
                               const jointName = jointSpaces[offset].jointName;
@@ -4832,7 +5438,7 @@
                   actionFrame.inputFrames.push(inputFrame);
               }
           });
-          this[PRIVATE].compressedFrames.push(this.compressActionFrame(actionFrame));
+          this[P_ACTION_RECORDER].compressedFrames.push(this.compressActionFrame(actionFrame));
       }
       compressActionFrame(af) {
           const out = [
@@ -4842,7 +5448,7 @@
           ];
           af.inputFrames.forEach((inputFrame) => {
               const index = inputFrame.index;
-              const schema = this[PRIVATE].schemaMap.get(index);
+              const schema = this[P_ACTION_RECORDER].schemaMap.get(index);
               const inputOut = [
                   index,
                   ...compress(inputFrame.targetRayTransform.position),
@@ -4873,14 +5479,45 @@
       }
       log() {
           const out = {
-              schema: Array.from(this[PRIVATE].schemaMap.entries()),
-              frames: this[PRIVATE].compressedFrames,
+              schema: Array.from(this[P_ACTION_RECORDER].schemaMap.entries()),
+              frames: this[P_ACTION_RECORDER].compressedFrames,
           };
           console.log(JSON.stringify(out));
       }
   }
 
   exports.ActionRecorder = ActionRecorder;
+  exports.NativeMesh = NativeMesh;
+  exports.NativePlane = NativePlane;
+  exports.P_ACTION_PLAYER = P_ACTION_PLAYER;
+  exports.P_ACTION_RECORDER = P_ACTION_RECORDER;
+  exports.P_ANCHOR = P_ANCHOR;
+  exports.P_CONTROLLER = P_CONTROLLER;
+  exports.P_DEVICE = P_DEVICE;
+  exports.P_FRAME = P_FRAME;
+  exports.P_GAMEPAD = P_GAMEPAD;
+  exports.P_HAND_INPUT = P_HAND_INPUT;
+  exports.P_HIT_TEST = P_HIT_TEST;
+  exports.P_INPUT_SOURCE = P_INPUT_SOURCE;
+  exports.P_JOINT_POSE = P_JOINT_POSE;
+  exports.P_JOINT_SPACE = P_JOINT_SPACE;
+  exports.P_MESH = P_MESH;
+  exports.P_PLANE = P_PLANE;
+  exports.P_POSE = P_POSE;
+  exports.P_RAY = P_RAY;
+  exports.P_REF_SPACE = P_REF_SPACE;
+  exports.P_RENDER_STATE = P_RENDER_STATE;
+  exports.P_RIGID_TRANSFORM = P_RIGID_TRANSFORM;
+  exports.P_SESSION = P_SESSION;
+  exports.P_SPACE = P_SPACE;
+  exports.P_SYSTEM = P_SYSTEM;
+  exports.P_TRACKED_INPUT = P_TRACKED_INPUT;
+  exports.P_VIEW = P_VIEW;
+  exports.P_VIEWER_POSE = P_VIEWER_POSE;
+  exports.P_VIEWPORT = P_VIEWPORT;
+  exports.P_WEBGL_LAYER = P_WEBGL_LAYER;
+  exports.XRAnchor = XRAnchor;
+  exports.XRAnchorSet = XRAnchorSet;
   exports.XRDevice = XRDevice;
   exports.XRFrame = XRFrame;
   exports.XRHand = XRHand;
@@ -4891,7 +5528,12 @@
   exports.XRJointPose = XRJointPose;
   exports.XRJointSpace = XRJointSpace;
   exports.XRLayer = XRLayer;
+  exports.XRMesh = XRMesh;
+  exports.XRMeshSet = XRMeshSet;
+  exports.XRPlane = XRPlane;
+  exports.XRPlaneSet = XRPlaneSet;
   exports.XRPose = XRPose;
+  exports.XRRay = XRRay;
   exports.XRReferenceSpace = XRReferenceSpace;
   exports.XRReferenceSpaceEvent = XRReferenceSpaceEvent;
   exports.XRRenderState = XRRenderState;