iwer 1.0.1 → 1.0.2

package/build/iwer.js

@@ -1287,11 +1287,11 @@
    * 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/xr-space');
+  const PRIVATE$l = Symbol('@immersive-web-emulation-runtime/xr-space');
   class XRSpace extends EventTarget {
       constructor(parentSpace, offsetMatrix) {
           super();
-          this[PRIVATE$k] = {
+          this[PRIVATE$l] = {
               parentSpace,
               offsetMatrix: offsetMatrix ? clone(offsetMatrix) : create$3(),
               emulated: true,
@@ -1306,27 +1306,27 @@
   class XRSpaceUtils {
       // Update the position component of the offsetMatrix of a given XRSpace
       static updateOffsetPosition(space, position) {
-          const offsetMatrix = space[PRIVATE$k].offsetMatrix;
+          const offsetMatrix = space[PRIVATE$l].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$k].offsetMatrix;
+          const offsetMatrix = space[PRIVATE$l].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$k].offsetMatrix;
+          const offsetMatrix = space[PRIVATE$l].offsetMatrix;
           copy$3(offsetMatrix, matrix);
       }
       // Calculate the global offset matrix for a given XRSpace
       static calculateGlobalOffsetMatrix(space, globalOffset = create$3()) {
-          const parentOffset = space[PRIVATE$k].parentSpace
-              ? XRSpaceUtils.calculateGlobalOffsetMatrix(space[PRIVATE$k].parentSpace)
+          const parentOffset = space[PRIVATE$l].parentSpace
+              ? XRSpaceUtils.calculateGlobalOffsetMatrix(space[PRIVATE$l].parentSpace)
               : create$3(); // Identity matrix for GlobalSpace
-          multiply$1(globalOffset, parentOffset, space[PRIVATE$k].offsetMatrix);
+          multiply$1(globalOffset, parentOffset, space[PRIVATE$l].offsetMatrix);
           return globalOffset;
       }
   }
@@ -1470,7 +1470,7 @@
    * This source code is licensed under the MIT license found in the
    * LICENSE file in the root directory of this source tree.
    */
-  const PRIVATE$j = Symbol('@immersive-web-emulation-runtime/gamepad');
+  const PRIVATE$k = Symbol('@immersive-web-emulation-runtime/gamepad');
   var GamepadMappingType;
   (function (GamepadMappingType) {
       GamepadMappingType["None"] = "";
@@ -1479,7 +1479,7 @@
   })(GamepadMappingType || (GamepadMappingType = {}));
   class GamepadButton {
       constructor(type, eventTrigger) {
-          this[PRIVATE$j] = {
+          this[PRIVATE$k] = {
               type,
               eventTrigger,
               pressed: false,
@@ -1490,23 +1490,23 @@
           };
       }
       get pressed() {
-          if (this[PRIVATE$j].type === 'manual') {
-              return this[PRIVATE$j].pressed;
+          if (this[PRIVATE$k].type === 'manual') {
+              return this[PRIVATE$k].pressed;
           }
           else {
-              return this[PRIVATE$j].value > 0;
+              return this[PRIVATE$k].value > 0;
           }
       }
       get touched() {
-          if (this[PRIVATE$j].type === 'manual') {
-              return this[PRIVATE$j].touched;
+          if (this[PRIVATE$k].type === 'manual') {
+              return this[PRIVATE$k].touched;
           }
           else {
-              return this[PRIVATE$j].touched || this.pressed;
+              return this[PRIVATE$k].touched || this.pressed;
           }
       }
       get value() {
-          return this[PRIVATE$j].value;
+          return this[PRIVATE$k].value;
       }
   }
   class EmptyGamepadButton {
@@ -1518,7 +1518,7 @@
   }
   class Gamepad {
       constructor(gamepadConfig, id = '', index = -1) {
-          this[PRIVATE$j] = {
+          this[PRIVATE$k] = {
               id,
               index,
               connected: false,
@@ -1533,43 +1533,43 @@
           gamepadConfig.buttons.forEach((buttonConfig) => {
               var _a;
               if (buttonConfig === null) {
-                  this[PRIVATE$j].buttonsSequence.push(null);
+                  this[PRIVATE$k].buttonsSequence.push(null);
               }
               else {
-                  this[PRIVATE$j].buttonsSequence.push(buttonConfig.id);
-                  this[PRIVATE$j].buttonsMap[buttonConfig.id] = new GamepadButton(buttonConfig.type, (_a = buttonConfig.eventTrigger) !== null && _a !== void 0 ? _a : null);
+                  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);
               }
           });
           gamepadConfig.axes.forEach((axisConfig) => {
               if (axisConfig === null) {
-                  this[PRIVATE$j].axesSequence.push(null);
+                  this[PRIVATE$k].axesSequence.push(null);
               }
               else {
-                  this[PRIVATE$j].axesSequence.push(axisConfig.id + axisConfig.type);
-                  if (!this[PRIVATE$j].axesMap[axisConfig.id]) {
-                      this[PRIVATE$j].axesMap[axisConfig.id] = { x: 0, y: 0 };
+                  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 };
                   }
               }
           });
       }
       get id() {
-          return this[PRIVATE$j].id;
+          return this[PRIVATE$k].id;
       }
       get index() {
-          return this[PRIVATE$j].index;
+          return this[PRIVATE$k].index;
       }
       get connected() {
-          return this[PRIVATE$j].connected;
+          return this[PRIVATE$k].connected;
       }
       get timestamp() {
-          return this[PRIVATE$j].timestamp;
+          return this[PRIVATE$k].timestamp;
       }
       get mapping() {
-          return this[PRIVATE$j].mapping;
+          return this[PRIVATE$k].mapping;
       }
       get axes() {
           const axes = [];
-          this[PRIVATE$j].axesSequence.forEach((id) => {
+          this[PRIVATE$k].axesSequence.forEach((id) => {
               if (id === null) {
                   axes.push(null);
               }
@@ -1579,17 +1579,17 @@
                   axes.push(
                   // if axis type is manual, then return the x value
                   axisType === 'y-axis'
-                      ? this[PRIVATE$j].axesMap[axisId].y
-                      : this[PRIVATE$j].axesMap[axisId].x);
+                      ? this[PRIVATE$k].axesMap[axisId].y
+                      : this[PRIVATE$k].axesMap[axisId].x);
               }
           });
           return axes;
       }
       get buttons() {
-          return this[PRIVATE$j].buttonsSequence.map((id) => id === null ? new EmptyGamepadButton() : this[PRIVATE$j].buttonsMap[id]);
+          return this[PRIVATE$k].buttonsSequence.map((id) => id === null ? new EmptyGamepadButton() : this[PRIVATE$k].buttonsMap[id]);
       }
       get hapticActuators() {
-          return this[PRIVATE$j].hapticActuators;
+          return this[PRIVATE$k].hapticActuators;
       }
       get vibrationActuator() {
           return null;
@@ -1617,10 +1617,10 @@
   })(XRTargetRayMode || (XRTargetRayMode = {}));
   class XRInputSourceArray extends Array {
   }
-  const PRIVATE$i = Symbol('@immersive-web-emulation-runtime/xr-input-source');
+  const PRIVATE$j = Symbol('@immersive-web-emulation-runtime/xr-input-source');
   class XRInputSource {
       constructor(handedness, targetRayMode, profiles, targetRaySpace, gamepad, gripSpace, hand) {
-          this[PRIVATE$i] = {
+          this[PRIVATE$j] = {
               handedness,
               targetRayMode,
               targetRaySpace,
@@ -1631,25 +1631,25 @@
           };
       }
       get handedness() {
-          return this[PRIVATE$i].handedness;
+          return this[PRIVATE$j].handedness;
       }
       get targetRayMode() {
-          return this[PRIVATE$i].targetRayMode;
+          return this[PRIVATE$j].targetRayMode;
       }
       get targetRaySpace() {
-          return this[PRIVATE$i].targetRaySpace;
+          return this[PRIVATE$j].targetRaySpace;
       }
       get gripSpace() {
-          return this[PRIVATE$i].gripSpace;
+          return this[PRIVATE$j].gripSpace;
       }
       get profiles() {
-          return this[PRIVATE$i].profiles;
+          return this[PRIVATE$j].profiles;
       }
       get gamepad() {
-          return this[PRIVATE$i].gamepad;
+          return this[PRIVATE$j].gamepad;
       }
       get hand() {
-          return this[PRIVATE$i].hand;
+          return this[PRIVATE$j].hand;
       }
   }
 
@@ -1679,7 +1679,7 @@
    * 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-tracked-input');
+  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 +1696,7 @@
   };
   class XRTrackedInput {
       constructor(inputSource) {
-          this[PRIVATE$h] = {
+          this[PRIVATE$i] = {
               inputSource,
               position: DEFAULT_TRANSFORM[inputSource.handedness].position.clone(),
               quaternion: DEFAULT_TRANSFORM[inputSource.handedness].quaternion.clone(),
@@ -1706,59 +1706,59 @@
           };
       }
       get position() {
-          return this[PRIVATE$h].position;
+          return this[PRIVATE$i].position;
       }
       get quaternion() {
-          return this[PRIVATE$h].quaternion;
+          return this[PRIVATE$i].quaternion;
       }
       get inputSource() {
-          return this[PRIVATE$h].inputSource;
+          return this[PRIVATE$i].inputSource;
       }
       get connected() {
-          return this[PRIVATE$h].connected;
+          return this[PRIVATE$i].connected;
       }
       set connected(value) {
-          this[PRIVATE$h].connected = value;
-          this[PRIVATE$h].inputSource.gamepad[PRIVATE$j].connected = value;
+          this[PRIVATE$i].connected = value;
+          this[PRIVATE$i].inputSource.gamepad[PRIVATE$k].connected = value;
       }
       onFrameStart(frame) {
-          const targetRaySpace = this[PRIVATE$h].inputSource.targetRaySpace;
-          fromRotationTranslation(targetRaySpace[PRIVATE$k].offsetMatrix, this[PRIVATE$h].quaternion.quat, this[PRIVATE$h].position.vec3);
+          const targetRaySpace = this[PRIVATE$i].inputSource.targetRaySpace;
+          fromRotationTranslation(targetRaySpace[PRIVATE$l].offsetMatrix, this[PRIVATE$i].quaternion.quat, this[PRIVATE$i].position.vec3);
           const session = frame.session;
-          this[PRIVATE$h].inputSource.gamepad.buttons.forEach((button) => {
+          this[PRIVATE$i].inputSource.gamepad.buttons.forEach((button) => {
               if (button instanceof GamepadButton) {
                   // apply pending values and record last frame values
-                  button[PRIVATE$j].lastFrameValue = button[PRIVATE$j].value;
-                  if (button[PRIVATE$j].pendingValue != null) {
-                      button[PRIVATE$j].value = button[PRIVATE$j].pendingValue;
-                      button[PRIVATE$j].pendingValue = null;
+                  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;
                   }
                   // trigger input source events
-                  if (button[PRIVATE$j].eventTrigger != null) {
-                      if (button[PRIVATE$j].lastFrameValue === 0 &&
-                          button[PRIVATE$j].value > 0) {
-                          session.dispatchEvent(new XRInputSourceEvent(button[PRIVATE$j].eventTrigger, {
+                  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, {
                               frame,
-                              inputSource: this[PRIVATE$h].inputSource,
+                              inputSource: this[PRIVATE$i].inputSource,
                           }));
-                          session.dispatchEvent(new XRInputSourceEvent(button[PRIVATE$j].eventTrigger + 'start', {
+                          session.dispatchEvent(new XRInputSourceEvent(button[PRIVATE$k].eventTrigger + 'start', {
                               frame,
-                              inputSource: this[PRIVATE$h].inputSource,
+                              inputSource: this[PRIVATE$i].inputSource,
                           }));
                       }
-                      else if (button[PRIVATE$j].lastFrameValue > 0 &&
-                          button[PRIVATE$j].value === 0) {
-                          session.dispatchEvent(new XRInputSourceEvent(button[PRIVATE$j].eventTrigger + 'end', {
+                      else if (button[PRIVATE$k].lastFrameValue > 0 &&
+                          button[PRIVATE$k].value === 0) {
+                          session.dispatchEvent(new XRInputSourceEvent(button[PRIVATE$k].eventTrigger + 'end', {
                               frame,
-                              inputSource: this[PRIVATE$h].inputSource,
+                              inputSource: this[PRIVATE$i].inputSource,
                           }));
                       }
                   }
               }
           });
-          this[PRIVATE$h].inputSourceChanged =
-              this.connected !== this[PRIVATE$h].lastFrameConnected;
-          this[PRIVATE$h].lastFrameConnected = this.connected;
+          this[PRIVATE$i].inputSourceChanged =
+              this.connected !== this[PRIVATE$i].lastFrameConnected;
+          this[PRIVATE$i].lastFrameConnected = this.connected;
       }
   }
 
@@ -1768,6 +1768,7 @@
    * 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]) {
@@ -1783,30 +1784,38 @@
           ];
           const inputSource = new XRInputSource(handedness, XRTargetRayMode.TrackedPointer, profiles, targetRaySpace, new Gamepad(controllerConfig.layout[handedness].gamepad), gripSpace);
           super(inputSource);
+          this[PRIVATE$h] = {
+              gamepadConfig: controllerConfig.layout[handedness].gamepad,
+          };
+      }
+      get gamepadConfig() {
+          return this[PRIVATE$h].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$h].inputSource.gamepad[PRIVATE$j].buttonsMap[id];
+          const gamepadButton = this[PRIVATE$i].inputSource.gamepad[PRIVATE$k]
+              .buttonsMap[id];
           if (gamepadButton) {
-              if (gamepadButton[PRIVATE$j].type === 'binary' &&
+              if (gamepadButton[PRIVATE$k].type === 'binary' &&
                   value != 1 &&
                   value != 0) {
                   console.warn(`Non-binary value ${value} provided for binary button ${id}.`);
                   return;
               }
-              gamepadButton[PRIVATE$j].pendingValue = value;
+              gamepadButton[PRIVATE$k].pendingValue = value;
           }
           else {
               console.warn(`Current controller does not have button ${id}.`);
           }
       }
       updateButtonTouch(id, touched) {
-          const gamepadButton = this[PRIVATE$h].inputSource.gamepad[PRIVATE$j].buttonsMap[id];
+          const gamepadButton = this[PRIVATE$i].inputSource.gamepad[PRIVATE$k]
+              .buttonsMap[id];
           if (gamepadButton) {
-              gamepadButton[PRIVATE$j].touched = touched;
+              gamepadButton[PRIVATE$k].touched = touched;
           }
           else {
               console.warn(`Current controller does not have button ${id}.`);
@@ -1817,7 +1826,8 @@
               console.warn(`Out-of-range value ${value} provided for ${id} axes.`);
               return;
           }
-          const axesById = this[PRIVATE$h].inputSource.gamepad[PRIVATE$j].axesMap[id];
+          const axesById = this[PRIVATE$i].inputSource.gamepad[PRIVATE$k]
+              .axesMap[id];
           if (axesById) {
               if (type === 'x-axis') {
                   axesById.x = value;
@@ -1835,7 +1845,8 @@
               console.warn(`Out-of-range value x:${x}, y:${y} provided for ${id} axes.`);
               return;
           }
-          const axesById = this[PRIVATE$h].inputSource.gamepad[PRIVATE$j].axesMap[id];
+          const axesById = this[PRIVATE$i].inputSource.gamepad[PRIVATE$k]
+              .axesMap[id];
           if (axesById) {
               axesById.x = x;
               axesById.y = y;
@@ -2770,20 +2781,20 @@
               const targetJointMatrix = targetPose.jointTransforms[jointName].offsetMatrix;
               const pinchJointMatrix = pinchPose.jointTransforms[jointName].offsetMatrix;
               const jointSpace = this.inputSource.hand.get(jointName);
-              interpolateMatrix(jointSpace[PRIVATE$k].offsetMatrix, targetJointMatrix, pinchJointMatrix, this.pinchValue);
+              interpolateMatrix(jointSpace[PRIVATE$l].offsetMatrix, targetJointMatrix, pinchJointMatrix, this.pinchValue);
               if (this.inputSource.handedness === XRHandedness.Right) {
-                  mirrorMatrixToRight(jointSpace[PRIVATE$k].offsetMatrix);
+                  mirrorMatrixToRight(jointSpace[PRIVATE$l].offsetMatrix);
               }
               jointSpace[PRIVATE$f].radius =
                   (1 - this.pinchValue) * targetPose.jointTransforms[jointName].radius +
                       this.pinchValue * pinchPose.jointTransforms[jointName].radius;
           });
           if (targetPose.gripOffsetMatrix && pinchPose.gripOffsetMatrix) {
-              interpolateMatrix(this.inputSource.gripSpace[PRIVATE$k].offsetMatrix, targetPose.gripOffsetMatrix, pinchPose.gripOffsetMatrix, this.pinchValue);
+              interpolateMatrix(this.inputSource.gripSpace[PRIVATE$l].offsetMatrix, targetPose.gripOffsetMatrix, pinchPose.gripOffsetMatrix, this.pinchValue);
           }
       }
       get pinchValue() {
-          return this[PRIVATE$h].inputSource.gamepad[PRIVATE$j]
+          return this[PRIVATE$i].inputSource.gamepad[PRIVATE$k]
               .buttonsMap['pinch'].value;
       }
       updatePinchValue(value) {
@@ -2791,9 +2802,9 @@
               console.warn(`Out-of-range value ${value} provided for pinch`);
               return;
           }
-          const gamepadButton = this[PRIVATE$h].inputSource.gamepad[PRIVATE$j]
+          const gamepadButton = this[PRIVATE$i].inputSource.gamepad[PRIVATE$k]
               .buttonsMap['pinch'];
-          gamepadButton[PRIVATE$j].pendingValue = value;
+          gamepadButton[PRIVATE$k].pendingValue = value;
       }
       onFrameStart(frame) {
           super.onFrameStart(frame);
@@ -3004,7 +3015,7 @@
               y: orientation[1],
               z: orientation[2],
               w: orientation[3],
-          }), space[PRIVATE$k].emulated);
+          }), space[PRIVATE$l].emulated);
       }
       getViewerPose(referenceSpace) {
           if (!this[PRIVATE$9].animationFrame) {
@@ -3470,7 +3481,7 @@
                       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$k].offsetMatrix);
+                      referenceSpace = new XRReferenceSpace(type, this[PRIVATE$6].device[PRIVATE$1].globalSpace, this[PRIVATE$6].device.viewerSpace[PRIVATE$l].offsetMatrix);
                       break;
                   case XRReferenceSpaceType.LocalFloor:
                   case XRReferenceSpaceType.BoundedFloor:
@@ -3736,7 +3747,76 @@
    * 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/action-player');
+  const PRIVATE$4 = Symbol('@immersive-web-emulation-runtime/xr-system');
+  class XRSystem extends EventTarget {
+      constructor(device) {
+          super();
+          this[PRIVATE$4] = { device };
+          // Initialize device change monitoring here if applicable
+      }
+      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));
+              }
+          });
+      }
+      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);
+          });
+      }
+  }
+
+  /**
+   * 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$3 = Symbol('@immersive-web-emulation-runtime/action-player');
   class ActionPlayer {
       constructor(refSpace, recording, ipd) {
           const { schema, frames } = recording;
@@ -3749,7 +3829,7 @@
               [XREye.Right]: new XRSpace(viewerSpace),
               [XREye.None]: new XRSpace(viewerSpace),
           };
-          this[PRIVATE$4] = {
+          this[PRIVATE$3] = {
               refSpace,
               inputSources: new Map(),
               inputSchemas: new Map(),
@@ -3764,8 +3844,8 @@
               vec3: create$2(),
               quat: create(),
           };
-          fromTranslation(this[PRIVATE$4].viewSpaces[XREye.Left][PRIVATE$k].offsetMatrix, fromValues$2(-ipd / 2, 0, 0));
-          fromTranslation(this[PRIVATE$4].viewSpaces[XREye.Right][PRIVATE$k].offsetMatrix, fromValues$2(ipd / 2, 0, 0));
+          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));
           schema.forEach((schemaEntry) => {
               const index = schemaEntry[0];
               const schema = schemaEntry[1];
@@ -3794,53 +3874,53 @@
                   });
               }
               const inputSource = new XRInputSource(schema.handedness, schema.targetRayMode, schema.profiles, targetRaySpace, gamepad, schema.hasGrip ? new XRSpace(refSpace) : undefined, schema.hasHand ? hand : undefined);
-              this[PRIVATE$4].inputSources.set(index, {
+              this[PRIVATE$3].inputSources.set(index, {
                   active: false,
                   source: inputSource,
               });
-              this[PRIVATE$4].inputSchemas.set(index, schema);
+              this[PRIVATE$3].inputSchemas.set(index, schema);
           });
       }
       play() {
-          this[PRIVATE$4].recordedFramePointer = 0;
-          this[PRIVATE$4].playbackTime = this[PRIVATE$4].startingTimeStamp;
-          this[PRIVATE$4].playing = true;
-          this[PRIVATE$4].actualTimeStamp = performance.now();
+          this[PRIVATE$3].recordedFramePointer = 0;
+          this[PRIVATE$3].playbackTime = this[PRIVATE$3].startingTimeStamp;
+          this[PRIVATE$3].playing = true;
+          this[PRIVATE$3].actualTimeStamp = performance.now();
       }
       stop() {
-          this[PRIVATE$4].playing = false;
+          this[PRIVATE$3].playing = false;
       }
       get playing() {
-          return this[PRIVATE$4].playing;
+          return this[PRIVATE$3].playing;
       }
       get viewerSpace() {
-          return this[PRIVATE$4].viewerSpace;
+          return this[PRIVATE$3].viewerSpace;
       }
       get viewSpaces() {
-          return this[PRIVATE$4].viewSpaces;
+          return this[PRIVATE$3].viewSpaces;
       }
       get inputSources() {
-          return Array.from(this[PRIVATE$4].inputSources.values())
+          return Array.from(this[PRIVATE$3].inputSources.values())
               .filter((wrapper) => wrapper.active)
               .map((wrapper) => wrapper.source);
       }
       playFrame() {
           const now = performance.now();
-          const delta = now - this[PRIVATE$4].actualTimeStamp;
-          this[PRIVATE$4].actualTimeStamp = now;
-          this[PRIVATE$4].playbackTime += delta;
-          if (this[PRIVATE$4].playbackTime > this[PRIVATE$4].endingTimeStamp) {
+          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) {
               this.stop();
               return;
           }
-          while (this[PRIVATE$4].frames[this[PRIVATE$4].recordedFramePointer + 1][0] < this[PRIVATE$4].playbackTime) {
-              this[PRIVATE$4].recordedFramePointer++;
+          while (this[PRIVATE$3].frames[this[PRIVATE$3].recordedFramePointer + 1][0] < this[PRIVATE$3].playbackTime) {
+              this[PRIVATE$3].recordedFramePointer++;
           }
-          const lastFrameData = this[PRIVATE$4].frames[this[PRIVATE$4].recordedFramePointer];
-          const nextFrameData = this[PRIVATE$4].frames[this[PRIVATE$4].recordedFramePointer + 1];
-          const alpha = (this[PRIVATE$4].playbackTime - lastFrameData[0]) /
+          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]) /
               (nextFrameData[0] - lastFrameData[0]);
-          this.updateXRSpaceFromMergedFrames(this[PRIVATE$4].viewerSpace, lastFrameData.slice(1, 8), nextFrameData.slice(1, 8), alpha);
+          this.updateXRSpaceFromMergedFrames(this[PRIVATE$3].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]);
@@ -3851,13 +3931,13 @@
               const { index, inputData } = this.processRawInputData(nextFrameData[i]);
               nextFrameInputs.set(index, inputData);
           }
-          this[PRIVATE$4].inputSources.forEach((sourceWrapper) => {
+          this[PRIVATE$3].inputSources.forEach((sourceWrapper) => {
               sourceWrapper.active = false;
           });
           nextFrameInputs.forEach((inputData, index) => {
-              this[PRIVATE$4].inputSources.get(index).active = true;
-              const inputSource = this[PRIVATE$4].inputSources.get(index).source;
-              const schema = this[PRIVATE$4].inputSchemas.get(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.updateInputSource(inputSource, schema, lastFrameInputs.has(index) ? lastFrameInputs.get(index) : inputData, inputData, alpha);
           });
       }
@@ -3882,16 +3962,16 @@
               const gamepad = inputSource.gamepad;
               nextInputData.buttons.forEach((states, index) => {
                   const gamepadButton = gamepad.buttons[index];
-                  gamepadButton[PRIVATE$j].pressed = states[0] === 1 ? true : false;
-                  gamepadButton[PRIVATE$j].touched = states[1] === 1 ? true : false;
+                  gamepadButton[PRIVATE$k].pressed = states[0] === 1 ? true : false;
+                  gamepadButton[PRIVATE$k].touched = states[1] === 1 ? true : false;
                   const lastValue = lastInputData.buttons[index][2];
                   const nextValue = states[2];
-                  gamepadButton[PRIVATE$j].value =
+                  gamepadButton[PRIVATE$k].value =
                       (nextValue - lastValue) * alpha + lastValue;
               });
               nextInputData.axes.forEach((nextValue, index) => {
                   const lastValue = lastInputData.axes[index];
-                  gamepad[PRIVATE$j].axesMap[index.toString()].x =
+                  gamepad[PRIVATE$k].axesMap[index.toString()].x =
                       (nextValue - lastValue) * alpha + lastValue;
               });
           }
@@ -3901,13 +3981,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$4].vec3, f1p, f2p, alpha);
-          slerp(this[PRIVATE$4].quat, f1q, f2q, alpha);
-          fromRotationTranslation(space[PRIVATE$k].offsetMatrix, this[PRIVATE$4].quat, this[PRIVATE$4].vec3);
+          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);
       }
       processRawInputData(inputDataRaw) {
           const index = inputDataRaw[0];
-          const schema = this[PRIVATE$4].inputSchemas.get(index);
+          const schema = this[PRIVATE$3].inputSchemas.get(index);
           const targetRayTransform = inputDataRaw.slice(1, 8);
           const inputData = { targetRayTransform };
           let dataCounter = 8;
@@ -3926,7 +4006,7 @@
       }
   }
 
-  const VERSION = "1.0.1";
+  const VERSION = "1.0.2";
 
   /**
    * Copyright (c) Meta Platforms, Inc. and affiliates.
@@ -3945,75 +4025,6 @@
       }
   }
 
-  /**
-   * 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$3 = Symbol('@immersive-web-emulation-runtime/xr-system');
-  class XRSystem extends EventTarget {
-      constructor(device) {
-          super();
-          this[PRIVATE$3] = { device };
-          // Initialize device change monitoring here if applicable
-      }
-      isSessionSupported(mode) {
-          return new Promise((resolve, _reject) => {
-              if (mode === XRSessionMode.Inline) {
-                  resolve(true);
-              }
-              else {
-                  // Check for spatial tracking permission if necessary
-                  resolve(this[PRIVATE$3].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[PRIVATE$3].activeSession) {
-                      reject(new DOMException('An active XRSession already exists.', 'InvalidStateError'));
-                      return;
-                  }
-                  // Handle required and optional features
-                  const { requiredFeatures = [], optionalFeatures = [] } = options;
-                  const { supportedFeatures } = this[PRIVATE$3].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$3].device, mode, enabledFeatures);
-                  this[PRIVATE$3].activeSession = session;
-                  // Listen for session end to clear the active session
-                  session.addEventListener('end', () => {
-                      this[PRIVATE$3].activeSession = undefined;
-                  });
-                  resolve(session);
-              })
-                  .catch(reject);
-          });
-      }
-  }
-
   /**
    * Copyright (c) Meta Platforms, Inc. and affiliates.
    *
@@ -4126,6 +4137,7 @@
               pendingReferenceSpaceReset: false,
               visibilityState: XRVisibilityState.Visible,
               pendingVisibilityState: null,
+              xrSystem: null,
               matrix: create$3(),
               globalSpace,
               viewerSpace,
@@ -4146,10 +4158,10 @@
               updateViews: () => {
                   // update viewerSpace
                   const viewerSpace = this[PRIVATE$1].viewerSpace;
-                  fromRotationTranslation(viewerSpace[PRIVATE$k].offsetMatrix, this[PRIVATE$1].quaternion.quat, this[PRIVATE$1].position.vec3);
+                  fromRotationTranslation(viewerSpace[PRIVATE$l].offsetMatrix, this[PRIVATE$1].quaternion.quat, this[PRIVATE$1].position.vec3);
                   // update viewSpaces
-                  fromTranslation(this[PRIVATE$1].viewSpaces[XREye.Left][PRIVATE$k].offsetMatrix, fromValues$2(-this[PRIVATE$1].ipd / 2, 0, 0));
-                  fromTranslation(this[PRIVATE$1].viewSpaces[XREye.Right][PRIVATE$k].offsetMatrix, fromValues$2(this[PRIVATE$1].ipd / 2, 0, 0));
+                  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));
               },
               onBaseLayerSet: (baseLayer) => {
                   if (!baseLayer)
@@ -4231,8 +4243,9 @@
               },
               configurable: true,
           });
+          this[PRIVATE$1].xrSystem = new XRSystem(this);
           Object.defineProperty(globalThis.navigator, 'xr', {
-              value: new XRSystem(this),
+              value: this[PRIVATE$1].xrSystem,
               configurable: true,
           });
           Object.defineProperty(navigator, 'userAgent', {
@@ -4358,6 +4371,10 @@
       get canvasContainer() {
           return this[PRIVATE$1].canvasContainer;
       }
+      get activeSession() {
+          var _a;
+          return (_a = this[PRIVATE$1].xrSystem) === null || _a === void 0 ? void 0 : _a[PRIVATE$4].activeSession;
+      }
       recenter() {
           const deltaVec = new Vector3(-this.position.x, 0, -this.position.z);
           const forward = new Vector3(0, 0, -1).applyQuaternion(this.quaternion);