iwer 1.0.1 → 1.0.2

package/build/iwer.module.js

@@ -1281,11 +1281,11 @@ var normalize = normalize$1;
  * 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,
@@ -1300,27 +1300,27 @@ class GlobalSpace extends XRSpace {
 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;
     }
 }
@@ -1464,7 +1464,7 @@ class Quaternion {
  * 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"] = "";
@@ -1473,7 +1473,7 @@ var GamepadMappingType;
 })(GamepadMappingType || (GamepadMappingType = {}));
 class GamepadButton {
     constructor(type, eventTrigger) {
-        this[PRIVATE$j] = {
+        this[PRIVATE$k] = {
             type,
             eventTrigger,
             pressed: false,
@@ -1484,23 +1484,23 @@ class GamepadButton {
         };
     }
     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 {
@@ -1512,7 +1512,7 @@ class EmptyGamepadButton {
 }
 class Gamepad {
     constructor(gamepadConfig, id = '', index = -1) {
-        this[PRIVATE$j] = {
+        this[PRIVATE$k] = {
             id,
             index,
             connected: false,
@@ -1527,43 +1527,43 @@ class Gamepad {
         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);
             }
@@ -1573,17 +1573,17 @@ class Gamepad {
                 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;
@@ -1611,10 +1611,10 @@ var XRTargetRayMode;
 })(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,
@@ -1625,25 +1625,25 @@ class XRInputSource {
         };
     }
     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;
     }
 }
 
@@ -1673,7 +1673,7 @@ class XRInputSourceEvent extends Event {
  * 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),
@@ -1690,7 +1690,7 @@ const DEFAULT_TRANSFORM = {
 };
 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(),
@@ -1700,59 +1700,59 @@ class XRTrackedInput {
         };
     }
     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;
     }
 }
 
@@ -1762,6 +1762,7 @@ class XRTrackedInput {
  * 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]) {
@@ -1777,30 +1778,38 @@ class XRController extends XRTrackedInput {
         ];
         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}.`);
@@ -1811,7 +1820,8 @@ class XRController extends XRTrackedInput {
             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;
@@ -1829,7 +1839,8 @@ class XRController extends XRTrackedInput {
             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;
@@ -2764,20 +2775,20 @@ class XRHandInput extends XRTrackedInput {
             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) {
@@ -2785,9 +2796,9 @@ class XRHandInput extends XRTrackedInput {
             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);
@@ -2998,7 +3009,7 @@ class XRFrame {
             y: orientation[1],
             z: orientation[2],
             w: orientation[3],
-        }), space[PRIVATE$k].emulated);
+        }), space[PRIVATE$l].emulated);
     }
     getViewerPose(referenceSpace) {
         if (!this[PRIVATE$9].animationFrame) {
@@ -3464,7 +3475,7 @@ class XRSession extends EventTarget {
                     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:
@@ -3730,7 +3741,76 @@ class XRWebGLLayer extends XRLayer {
  * 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;
@@ -3743,7 +3823,7 @@ class ActionPlayer {
             [XREye.Right]: new XRSpace(viewerSpace),
             [XREye.None]: new XRSpace(viewerSpace),
         };
-        this[PRIVATE$4] = {
+        this[PRIVATE$3] = {
             refSpace,
             inputSources: new Map(),
             inputSchemas: new Map(),
@@ -3758,8 +3838,8 @@ class ActionPlayer {
             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];
@@ -3788,53 +3868,53 @@ class ActionPlayer {
                 });
             }
             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]);
@@ -3845,13 +3925,13 @@ class ActionPlayer {
             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);
         });
     }
@@ -3876,16 +3956,16 @@ class ActionPlayer {
             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;
             });
         }
@@ -3895,13 +3975,13 @@ class ActionPlayer {
         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;
@@ -3920,7 +4000,7 @@ class ActionPlayer {
     }
 }
 
-const VERSION = "1.0.1";
+const VERSION = "1.0.2";
 
 /**
  * Copyright (c) Meta Platforms, Inc. and affiliates.
@@ -3939,75 +4019,6 @@ class XRReferenceSpaceEvent extends Event {
     }
 }
 
-/**
- * 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.
  *
@@ -4120,6 +4131,7 @@ class XRDevice {
             pendingReferenceSpaceReset: false,
             visibilityState: XRVisibilityState.Visible,
             pendingVisibilityState: null,
+            xrSystem: null,
             matrix: create$3(),
             globalSpace,
             viewerSpace,
@@ -4140,10 +4152,10 @@ class XRDevice {
             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)
@@ -4225,8 +4237,9 @@ class XRDevice {
             },
             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', {
@@ -4352,6 +4365,10 @@ class XRDevice {
     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);