@woosh/meep-engine 3.35.0 → 3.36.0

package/src/engine/input/devices/xr/XRInputButton.js

@@ -0,0 +1,43 @@
+import { Vector1 } from "../../../../core/geom/Vector1.js";
+import { InputDeviceSwitch } from "../InputDeviceSwitch.js";
+
+/**
+ * One raw GamepadButton: its scalar amount and the two binary facts reported by the browser.
+ * pressed is not inferred from x; a partially depressed trigger need not be pressed.
+ * The device owns mutation. Switches and onChanged keep their identity across source replacement.
+ */
+export class XRInputButton extends Vector1 {
+    /** @readonly */
+    pressed = new InputDeviceSwitch();
+    /** @readonly */
+    touched = new InputDeviceSwitch();
+
+    #pressed = false;
+    #touched = false;
+
+    /**
+     * Stage binary state while updating the scalar. All numeric channels and poses are sampled before
+     * the device calls flushSwitches, so an input-map action can read the corresponding amount.
+     * @internal
+     * @param {{value: number, pressed: boolean, touched: boolean}|undefined} button
+     */
+    update(button) {
+        this.#pressed = button !== undefined && button.pressed;
+        this.#touched = button !== undefined && button.touched;
+        this.set(button === undefined ? 0 : button.value);
+    }
+
+    /** @internal */
+    flushSwitches() {
+        if (this.#pressed) {
+            this.pressed.press();
+        } else {
+            this.pressed.release();
+        }
+        if (this.#touched) {
+            this.touched.press();
+        } else {
+            this.touched.release();
+        }
+    }
+}

package/src/engine/input/devices/xr/XRInputCoordinates.d.ts

@@ -0,0 +1,15 @@
+/** @param {number} index Native button index. @returns {number} Scalar amount, not pressed/touched. */
+export function xr_input_button_coordinate(index: number): number;
+/** @param {number} index Native axis index. @returns {number} */
+export function xr_input_axis_coordinate(index: number): number;
+/**
+ * Stable codes used in serialized input maps.
+ */
+export type XRInputCoordinates = number;
+export namespace XRInputCoordinates {
+    let select: number;
+    let squeeze: number;
+    let thumbstick: number;
+    let touchpad: number;
+}
+//# sourceMappingURL=XRInputCoordinates.d.ts.map

package/src/engine/input/devices/xr/XRInputCoordinates.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"XRInputCoordinates.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/input/devices/xr/XRInputCoordinates.js"],"names":[],"mappings":"AAUA,uGAAuG;AACvG,kDADY,MAAM,GAAuC,MAAM,CAI9D;AAED,iEAAiE;AACjE,gDADY,MAAM,GAAqC,MAAM,CAI5D;;;;iCAlBoB,MAAM"}

package/src/engine/input/devices/xr/XRInputCoordinates.js

@@ -0,0 +1,21 @@
+import { assert } from "../../../../core/assert.js";
+
+/** @readonly @enum {number} Stable codes used in serialized input maps. */
+export const XRInputCoordinates = {
+    select: 0,
+    squeeze: 1,
+    thumbstick: 2,
+    touchpad: 3
+};
+
+/** @param {number} index Native button index. @returns {number} Scalar amount, not pressed/touched. */
+export function xr_input_button_coordinate(index) {
+    assert.isNonNegativeInteger(index, 'index');
+    return 4 + index * 2;
+}
+
+/** @param {number} index Native axis index. @returns {number} */
+export function xr_input_axis_coordinate(index) {
+    assert.isNonNegativeInteger(index, 'index');
+    return 5 + index * 2;
+}

package/src/engine/input/devices/xr/XRInputHandle.d.ts

@@ -0,0 +1,63 @@
+/**
+ * One XR input source, or a persistent handedness slot owned by XRInputDevice.
+ * All control objects survive disconnection. Consumers read them; the device owns mutation.
+ * Only xr-standard supplies known button/axis semantics. Other mappings remain available through
+ * buttons/axes, while select/squeeze use the explicitly identified binary action fallback.
+ *
+ * Button indices 0/1 are select/squeeze; axes 0/1 are touchpad and 2/3 thumbstick in xr-standard.
+ * Placeholder entries are allowed by WebXR: a zero entry does not prove that a control exists.
+ */
+export class XRInputHandle {
+    /** @readonly */
+    readonly select: XRInputAction;
+    /** @readonly */
+    readonly squeeze: XRInputAction;
+    /** @readonly @type {XRInputButton[]} Use getButton for an index that may not exist yet. */
+    readonly buttons: XRInputButton[];
+    /** @readonly @type {Vector1[]} Use getAxis for an index that may not exist yet. */
+    readonly axes: Vector1[];
+    /** @readonly */
+    readonly thumbstick: GamepadStick;
+    /** @readonly Uncalibrated pad coordinates, +x right, +y down. */
+    readonly touchpad: Vector2;
+    /** @readonly */
+    readonly targetRay: XRInputPose;
+    /** @readonly */
+    readonly grip: XRInputPose;
+    /** @readonly @type {import('./XRInputTypes.js').XRInputSource|null} Set by the device. */
+    readonly nativeSource: import('./XRInputTypes.js').XRInputSource | null;
+    /** Number of native entries, excluding controls materialised for bindings. */
+    buttonCount: number;
+    axisCount: number;
+    get connected(): boolean;
+    get handedness(): string;
+    get targetRayMode(): string;
+    /** @returns {ReadonlyArray<string>} */
+    get profiles(): readonly string[];
+    /** @param {number} index @returns {XRInputButton} */
+    getButton(index: number): XRInputButton;
+    /** @param {number} index @returns {Vector1} */
+    getAxis(index: number): Vector1;
+    /** @internal @param {import('./XRInputTypes.js').XRInputSource|null} source */
+    bind(source: import('./XRInputTypes.js').XRInputSource | null): void;
+    /**
+     * @internal Sample values and poses before publishing raw switch edges.
+     * @param {import('./XRInputTypes.js').XRFrame|null} frame
+     * @param {EventTarget|null} referenceSpace
+     */
+    sample(frame: import('./XRInputTypes.js').XRFrame | null, referenceSpace: EventTarget | null): void;
+    /** @internal Tracking loss does not imply release or cancellation. */
+    invalidatePoses(): void;
+    /** @internal Neutralise everything before switch releases and cancellation callbacks. */
+    clear(): void;
+    /** @internal */
+    flush(): void;
+    #private;
+}
+import { XRInputAction } from "./XRInputAction.js";
+import { XRInputButton } from "./XRInputButton.js";
+import { Vector1 } from "../../../../core/geom/Vector1.js";
+import { GamepadStick } from "../gamepad/GamepadStick.js";
+import Vector2 from "../../../../core/geom/Vector2.js";
+import { XRInputPose } from "./XRInputPose.js";
+//# sourceMappingURL=XRInputHandle.d.ts.map

package/src/engine/input/devices/xr/XRInputHandle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"XRInputHandle.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/input/devices/xr/XRInputHandle.js"],"names":[],"mappings":"AAYA;;;;;;;;GAQG;AACH;IACI,gBAAgB;IAChB,+BAA6B;IAC7B,gBAAgB;IAChB,gCAA8B;IAC9B,2FAA2F;IAC3F,kBADqB,aAAa,EAAE,CACvB;IACb,mFAAmF;IACnF,eADqB,OAAO,EAAE,CACpB;IACV,gBAAgB;IAChB,kCAAoC;IACpC,iEAAiE;IACjE,2BAAyB;IACzB,gBAAgB;IAChB,gCAA8B;IAC9B,gBAAgB;IAChB,2BAAyB;IAEzB,0FAA0F;IAC1F,uBADqB,OAAO,mBAAmB,EAAE,aAAa,GAAC,IAAI,CAC/C;IAIpB,8EAA8E;IAC9E,oBAAgB;IAChB,kBAAc;IAOd,yBAAsD;IACtD,yBAA+F;IAC/F,4BAAiG;IACjG,uCAAuC;IACvC,kCAAgG;IAEhG,qDAAqD;IACrD,iBADY,MAAM,GAAkB,aAAa,CAOhD;IAED,+CAA+C;IAC/C,eADY,MAAM,GAAkB,OAAO,CAO1C;IAED,+EAA+E;IAC/E,aADsB,OAAO,mBAAmB,EAAE,aAAa,GAAC,IAAI,QAUnE;IAED;;;;OAIG;IACH,cAHW,OAAO,mBAAmB,EAAE,OAAO,GAAC,IAAI,kBACxC,WAAW,GAAC,IAAI,QA4C1B;IAED,sEAAsE;IACtE,wBAGC;IAED,yFAAyF;IACzF,cAeC;IAED,gBAAgB;IAChB,cAMC;;CACJ;8BAtK6B,oBAAoB;8BACpB,oBAAoB;wBAJ1B,kCAAkC;6BAE7B,4BAA4B;oBADrC,kCAAkC;4BAI1B,kBAAkB"}

package/src/engine/input/devices/xr/XRInputHandle.js

@@ -0,0 +1,171 @@
+import { assert } from "../../../../core/assert.js";
+import { Vector1 } from "../../../../core/geom/Vector1.js";
+import Vector2 from "../../../../core/geom/Vector2.js";
+import { GamepadStick } from "../gamepad/GamepadStick.js";
+import { XRInputAction } from "./XRInputAction.js";
+import { XRInputButton } from "./XRInputButton.js";
+import { XRInputPose } from "./XRInputPose.js";
+import { XRInputValueSource } from "./XRInputValueSource.js";
+
+/** @type {ReadonlyArray<string>} */
+const NO_PROFILES = Object.freeze([]);
+
+/**
+ * One XR input source, or a persistent handedness slot owned by XRInputDevice.
+ * All control objects survive disconnection. Consumers read them; the device owns mutation.
+ * Only xr-standard supplies known button/axis semantics. Other mappings remain available through
+ * buttons/axes, while select/squeeze use the explicitly identified binary action fallback.
+ *
+ * Button indices 0/1 are select/squeeze; axes 0/1 are touchpad and 2/3 thumbstick in xr-standard.
+ * Placeholder entries are allowed by WebXR: a zero entry does not prove that a control exists.
+ */
+export class XRInputHandle {
+    /** @readonly */
+    select = new XRInputAction();
+    /** @readonly */
+    squeeze = new XRInputAction();
+    /** @readonly @type {XRInputButton[]} Use getButton for an index that may not exist yet. */
+    buttons = [];
+    /** @readonly @type {Vector1[]} Use getAxis for an index that may not exist yet. */
+    axes = [];
+    /** @readonly */
+    thumbstick = new GamepadStick(2, 3);
+    /** @readonly Uncalibrated pad coordinates, +x right, +y down. */
+    touchpad = new Vector2();
+    /** @readonly */
+    targetRay = new XRInputPose();
+    /** @readonly */
+    grip = new XRInputPose();
+
+    /** @readonly @type {import('./XRInputTypes.js').XRInputSource|null} Set by the device. */
+    nativeSource = null;
+    /** @type {number[]} */
+    #axisValues = [0, 0, 0, 0];
+
+    /** Number of native entries, excluding controls materialised for bindings. */
+    buttonCount = 0;
+    axisCount = 0;
+
+    constructor() {
+        this.getButton(3);
+        this.getAxis(3);
+    }
+
+    get connected() { return this.nativeSource !== null; }
+    get handedness() { return this.nativeSource === null ? 'none' : this.nativeSource.handedness; }
+    get targetRayMode() { return this.nativeSource === null ? '' : this.nativeSource.targetRayMode; }
+    /** @returns {ReadonlyArray<string>} */
+    get profiles() { return this.nativeSource === null ? NO_PROFILES : this.nativeSource.profiles; }
+
+    /** @param {number} index @returns {XRInputButton} */
+    getButton(index) {
+        assert.isNonNegativeInteger(index, 'index');
+        while (this.buttons.length <= index) {
+            this.buttons.push(new XRInputButton());
+        }
+        return this.buttons[index];
+    }
+
+    /** @param {number} index @returns {Vector1} */
+    getAxis(index) {
+        assert.isNonNegativeInteger(index, 'index');
+        while (this.axes.length <= index) {
+            this.axes.push(new Vector1());
+        }
+        return this.axes[index];
+    }
+
+    /** @internal @param {import('./XRInputTypes.js').XRInputSource|null} source */
+    bind(source) {
+        if (this.nativeSource === source) {
+            return;
+        }
+        this.nativeSource = null;
+        this.clear();
+        this.flush();
+        this.thumbstick.forgetCalibration();
+        this.nativeSource = source;
+    }
+
+    /**
+     * @internal Sample values and poses before publishing raw switch edges.
+     * @param {import('./XRInputTypes.js').XRFrame|null} frame
+     * @param {EventTarget|null} referenceSpace
+     */
+    sample(frame, referenceSpace) {
+        const source = this.nativeSource;
+        if (source === null) {
+            return;
+        }
+        // A source/visibility notification has no pose frame. Preserve the last sample in that case;
+        // only an actual unavailable pose, a reference-space change or cleanup invalidates it.
+        if (frame !== null) {
+            const ray = referenceSpace !== null ? frame.getPose(source.targetRaySpace, referenceSpace) ?? null : null;
+            const grip = referenceSpace !== null && source.gripSpace != null
+                ? frame.getPose(source.gripSpace, referenceSpace) ?? null : null;
+            this.targetRay.update(ray);
+            this.grip.update(grip);
+        }
+
+        const gamepad = source.gamepad;
+        const mapped = gamepad != null && gamepad.mapping === 'xr-standard';
+        this.buttonCount = gamepad == null ? 0 : gamepad.buttons.length;
+        this.axisCount = gamepad == null ? 0 : gamepad.axes.length;
+        if (this.buttonCount > 0) {
+            this.getButton(this.buttonCount - 1);
+        }
+        if (this.axisCount > 0) {
+            this.getAxis(this.axisCount - 1);
+        }
+        for (let i = 0; i < this.buttons.length; i++) {
+            this.buttons[i].update(i < this.buttonCount ? gamepad.buttons[i] : undefined);
+        }
+        for (let i = 0; i < this.axes.length; i++) {
+            const value = i < this.axisCount ? gamepad.axes[i] : 0;
+            this.#axisValues[i] = value;
+            this.axes[i].set(value);
+        }
+        if (mapped) {
+            this.touchpad.set(this.#axisValues[0], this.#axisValues[1]);
+            this.thumbstick.update(this.#axisValues);
+        } else {
+            this.touchpad.set(0, 0);
+            this.thumbstick.reset();
+        }
+        this.select.update(mapped && this.buttonCount > 0 ? XRInputValueSource.Gamepad : XRInputValueSource.Action, this.buttons[0].x);
+        this.squeeze.update(mapped && this.buttonCount > 1 ? XRInputValueSource.Gamepad : XRInputValueSource.Action, this.buttons[1].x);
+    }
+
+    /** @internal Tracking loss does not imply release or cancellation. */
+    invalidatePoses() {
+        this.targetRay.update(null);
+        this.grip.update(null);
+    }
+
+    /** @internal Neutralise everything before switch releases and cancellation callbacks. */
+    clear() {
+        this.invalidatePoses();
+        this.buttonCount = 0;
+        this.axisCount = 0;
+        for (let i = 0; i < this.buttons.length; i++) {
+            this.buttons[i].update(undefined);
+        }
+        for (let i = 0; i < this.axes.length; i++) {
+            this.axes[i].set(0);
+            this.#axisValues[i] = 0;
+        }
+        this.touchpad.set(0, 0);
+        this.thumbstick.reset();
+        this.select.reset();
+        this.squeeze.reset();
+    }
+
+    /** @internal */
+    flush() {
+        for (let i = 0; i < this.buttons.length; i++) {
+            this.buttons[i].flushSwitches();
+        }
+        this.select.flushCancellation();
+        this.squeeze.flushCancellation();
+    }
+}

package/src/engine/input/devices/xr/XRInputPose.d.ts

@@ -0,0 +1,23 @@
+/**
+ * A copied pose in the device's configured reference space. The device owns mutation.
+ * valid must be checked before use; an unavailable pose is cleared, not presented as valid identity.
+ * Target-ray forward is local -Z, regardless of a game's own forward convention.
+ */
+export class XRInputPose {
+    /** @readonly */
+    readonly position: Vector3;
+    /** @readonly */
+    readonly rotation: Quaternion;
+    /** @type {boolean} */
+    valid: boolean;
+    /** @type {boolean} */
+    emulatedPosition: boolean;
+    /**
+     * @internal
+     * @param {import("./XRInputTypes.js").XRPose|null} pose
+     */
+    update(pose: import("./XRInputTypes.js").XRPose | null): void;
+}
+import Vector3 from "../../../../core/geom/Vector3.js";
+import Quaternion from "../../../../core/geom/Quaternion.js";
+//# sourceMappingURL=XRInputPose.d.ts.map

package/src/engine/input/devices/xr/XRInputPose.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"XRInputPose.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/input/devices/xr/XRInputPose.js"],"names":[],"mappings":"AAGA;;;;GAIG;AACH;IACI,gBAAgB;IAChB,2BAAyB;IACzB,gBAAgB;IAChB,8BAA4B;IAC5B,sBAAsB;IACtB,OADW,OAAO,CACJ;IACd,sBAAsB;IACtB,kBADW,OAAO,CACO;IAEzB;;;OAGG;IACH,aAFW,OAAO,mBAAmB,EAAE,MAAM,GAAC,IAAI,QAcjD;CACJ;oBAlCmB,kCAAkC;uBAD/B,qCAAqC"}

package/src/engine/input/devices/xr/XRInputPose.js

@@ -0,0 +1,36 @@
+import Quaternion from "../../../../core/geom/Quaternion.js";
+import Vector3 from "../../../../core/geom/Vector3.js";
+
+/**
+ * A copied pose in the device's configured reference space. The device owns mutation.
+ * valid must be checked before use; an unavailable pose is cleared, not presented as valid identity.
+ * Target-ray forward is local -Z, regardless of a game's own forward convention.
+ */
+export class XRInputPose {
+    /** @readonly */
+    position = new Vector3();
+    /** @readonly */
+    rotation = new Quaternion();
+    /** @type {boolean} */
+    valid = false;
+    /** @type {boolean} */
+    emulatedPosition = false;
+
+    /**
+     * @internal
+     * @param {import("./XRInputTypes.js").XRPose|null} pose
+     */
+    update(pose) {
+        this.valid = pose !== null;
+        this.emulatedPosition = pose !== null && pose.emulatedPosition;
+        if (pose === null) {
+            this.position.set(0, 0, 0);
+            this.rotation.set(0, 0, 0, 1);
+        } else {
+            const p = pose.transform.position;
+            const q = pose.transform.orientation;
+            this.position.set(p.x, p.y, p.z);
+            this.rotation.set(q.x, q.y, q.z, q.w);
+        }
+    }
+}

package/src/engine/input/devices/xr/XRInputTypes.d.ts

@@ -0,0 +1,76 @@
+/**
+ * Structural subsets of WebXR used by the input boundary. Native WebXR objects satisfy these types;
+ * keeping the boundary structural also permits headless hosts and avoids requiring ambient XR globals
+ * in every consumer of Engine's generated declarations.
+ */
+export type XRGamepad = {
+    mapping: string;
+    buttons: ReadonlyArray<{
+        value: number;
+        pressed: boolean;
+        touched: boolean;
+    }>;
+    axes: ReadonlyArray<number>;
+};
+/**
+ * Structural subsets of WebXR used by the input boundary. Native WebXR objects satisfy these types;
+ * keeping the boundary structural also permits headless hosts and avoids requiring ambient XR globals
+ * in every consumer of Engine's generated declarations.
+ */
+export type XRInputSource = {
+    handedness: string;
+    targetRayMode: string;
+    profiles: ReadonlyArray<string>;
+    targetRaySpace: EventTarget;
+    gripSpace?: EventTarget | null;
+    gamepad?: XRGamepad | null;
+};
+/**
+ * Structural subsets of WebXR used by the input boundary. Native WebXR objects satisfy these types;
+ * keeping the boundary structural also permits headless hosts and avoids requiring ambient XR globals
+ * in every consumer of Engine's generated declarations.
+ */
+export type XRSession = EventTarget & {
+    readonly inputSources: ArrayLike<XRInputSource>;
+    readonly visibilityState: string;
+};
+/**
+ * Structural subsets of WebXR used by the input boundary. Native WebXR objects satisfy these types;
+ * keeping the boundary structural also permits headless hosts and avoids requiring ambient XR globals
+ * in every consumer of Engine's generated declarations.
+ */
+export type XRPose = {
+    transform: {
+        position: {
+            x: number;
+            y: number;
+            z: number;
+        };
+        orientation: {
+            x: number;
+            y: number;
+            z: number;
+            w: number;
+        };
+    };
+    emulatedPosition: boolean;
+};
+/**
+ * Structural subsets of WebXR used by the input boundary. Native WebXR objects satisfy these types;
+ * keeping the boundary structural also permits headless hosts and avoids requiring ambient XR globals
+ * in every consumer of Engine's generated declarations.
+ */
+export type XRFrame = {
+    session: XRSession;
+    getPose: (space: EventTarget, baseSpace: EventTarget) => XRPose | null | undefined;
+};
+/**
+ * Structural subsets of WebXR used by the input boundary. Native WebXR objects satisfy these types;
+ * keeping the boundary structural also permits headless hosts and avoids requiring ambient XR globals
+ * in every consumer of Engine's generated declarations.
+ */
+export type XRSessionInputEvent = Event & {
+    inputSource?: XRInputSource;
+    frame?: XRFrame;
+};
+//# sourceMappingURL=XRInputTypes.d.ts.map

package/src/engine/input/devices/xr/XRInputTypes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"XRInputTypes.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/input/devices/xr/XRInputTypes.js"],"names":[],"mappings":";;;;;;aAMc,MAAM;aACN,cAAc;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,OAAO,CAAC;QAAC,OAAO,EAAE,OAAO,CAAA;KAAC,CAAC;UAClE,cAAc,MAAM,CAAC;;;;;;;;gBAGrB,MAAM;mBACN,MAAM;cACN,cAAc,MAAM,CAAC;oBACrB,WAAW;gBACX,WAAW,GAAC,IAAI;cAChB,SAAS,GAAC,IAAI;;;;;;;wBAEf,WAAW,GAAG;IAAC,QAAQ,CAAC,YAAY,EAAE,UAAU,aAAa,CAAC,CAAC;IAAC,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAA;CAAC;;;;;;;eAGhG;QAAC,QAAQ,EAAE;YAAC,CAAC,EAAE,MAAM,CAAC;YAAC,CAAC,EAAE,MAAM,CAAC;YAAC,CAAC,EAAE,MAAM,CAAA;SAAC,CAAC;QAAC,WAAW,EAAE;YAAC,CAAC,EAAE,MAAM,CAAC;YAAC,CAAC,EAAE,MAAM,CAAC;YAAC,CAAC,EAAE,MAAM,CAAC;YAAC,CAAC,EAAE,MAAM,CAAA;SAAC,CAAA;KAAC;sBACxG,OAAO;;;;;;;;aAGP,SAAS;aACT,CAAC,KAAK,EAAE,WAAW,EAAE,SAAS,EAAE,WAAW,KAAK,MAAM,GAAC,IAAI,GAAC,SAAS;;;;;;;kCAEtE,KAAK,GAAG;IAAC,WAAW,CAAC,EAAE,aAAa,CAAC;IAAC,KAAK,CAAC,EAAE,OAAO,CAAA;CAAC"}

package/src/engine/input/devices/xr/XRInputTypes.js

@@ -0,0 +1,31 @@
+/**
+ * Structural subsets of WebXR used by the input boundary. Native WebXR objects satisfy these types;
+ * keeping the boundary structural also permits headless hosts and avoids requiring ambient XR globals
+ * in every consumer of Engine's generated declarations.
+ *
+ * @typedef {object} XRGamepad
+ * @property {string} mapping
+ * @property {ReadonlyArray<{value: number, pressed: boolean, touched: boolean}>} buttons
+ * @property {ReadonlyArray<number>} axes
+ *
+ * @typedef {object} XRInputSource
+ * @property {string} handedness
+ * @property {string} targetRayMode
+ * @property {ReadonlyArray<string>} profiles
+ * @property {EventTarget} targetRaySpace
+ * @property {EventTarget|null} [gripSpace]
+ * @property {XRGamepad|null} [gamepad]
+ *
+ * @typedef {EventTarget & {readonly inputSources: ArrayLike<XRInputSource>, readonly visibilityState: string}} XRSession
+ *
+ * @typedef {object} XRPose
+ * @property {{position: {x: number, y: number, z: number}, orientation: {x: number, y: number, z: number, w: number}}} transform
+ * @property {boolean} emulatedPosition
+ *
+ * @typedef {object} XRFrame
+ * @property {XRSession} session
+ * @property {(space: EventTarget, baseSpace: EventTarget) => XRPose|null|undefined} getPose
+ *
+ * @typedef {Event & {inputSource?: XRInputSource, frame?: XRFrame}} XRSessionInputEvent
+ */
+export {};

package/src/engine/input/devices/xr/XRInputValueSource.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Where an XR action's scalar comes from. Gamepad means a native button value, which may itself be
+ * digital. Action means an event-derived 0/1 value, not a measurement of pressure.
+ */
+export type XRInputValueSource = number;
+export namespace XRInputValueSource {
+    let Unavailable: number;
+    let Gamepad: number;
+    let Action: number;
+}
+//# sourceMappingURL=XRInputValueSource.d.ts.map

package/src/engine/input/devices/xr/XRInputValueSource.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"XRInputValueSource.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/input/devices/xr/XRInputValueSource.js"],"names":[],"mappings":";;;;iCAIU,MAAM"}

package/src/engine/input/devices/xr/XRInputValueSource.js

@@ -0,0 +1,11 @@
+/**
+ * Where an XR action's scalar comes from. Gamepad means a native button value, which may itself be
+ * digital. Action means an event-derived 0/1 value, not a measurement of pressure.
+ * @readonly
+ * @enum {number}
+ */
+export const XRInputValueSource = {
+    Unavailable: 0,
+    Gamepad: 1,
+    Action: 2
+};

package/src/engine/input/ecs/ism/coordinate/InputCoordinateChannel.d.ts

@@ -1,3 +1,11 @@
+/**
+ * @typedef {import('./InputCoordinateChannelType.js').InputCoordinateChannelType} InputCoordinateChannelType
+ * @typedef {import('../InputSourceTable.js').InputSourceTable} InputSourceTable
+ * @typedef {import('../device/InputDeviceAdapter.js').InputDeviceAdapter} InputDeviceAdapter
+ * @typedef {import('../InputSource.js').InputSource} InputSource
+ * @typedef {import('../trigger/InputTrigger.js').InputTrigger} InputTrigger
+ * @typedef {import('../../../../../core/binary/BitSet.js').BitSet} BitSet
+ */
 /**
  * An N-dimensional analog channel an action can be bound to.
  *
@@ -16,7 +24,7 @@ export class InputCoordinateChannel {
     /**
      * @returns {InputCoordinateChannelType}
      */
-    get type(): InputCoordinateChannelType;
+    get type(): number;
     /**
      * Component count.
      * @returns {number}
@@ -64,4 +72,10 @@ export class InputCoordinateChannel {
      */
     hash(): number;
 }
+export type InputCoordinateChannelType = import('./InputCoordinateChannelType.js').InputCoordinateChannelType;
+export type InputSourceTable = import('../InputSourceTable.js').InputSourceTable;
+export type InputDeviceAdapter = import('../device/InputDeviceAdapter.js').InputDeviceAdapter;
+export type InputSource = import('../InputSource.js').InputSource;
+export type InputTrigger = import('../trigger/InputTrigger.js').InputTrigger;
+export type BitSet = import('../../../../../core/binary/BitSet.js').BitSet;
 //# sourceMappingURL=InputCoordinateChannel.d.ts.map

package/src/engine/input/ecs/ism/coordinate/InputCoordinateChannel.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"InputCoordinateChannel.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/input/ecs/ism/coordinate/InputCoordinateChannel.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AACH;IAEI;;OAEG;IACH,uCAEC;IAED;;;OAGG;IACH,yBAEC;IAED;;;;;;OAMG;IACH,2CAFW,IAAI,MAAM,qBAAqB,QAIzC;IAED;;OAEG;IACH,uBAFW,aAAa,QAIvB;IAED;;;;;;;;OAQG;IACH,wBAFW,cAAc,QAIxB;IAED;;;;OAIG;IACH,aAJW,MAAM,EAAE,GAAC,YAAY,UACrB,MAAM,sBAKhB;IAED;;OAEG;IACH,SAFa,sBAAsB,CAIlC;IAED;;;OAGG;IACH,cAHW,sBAAsB,GACpB,OAAO,CAInB;IAED;;OAEG;IACH,QAFa,MAAM,CAIlB;CACJ"}
+{"version":3,"file":"InputCoordinateChannel.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/input/ecs/ism/coordinate/InputCoordinateChannel.js"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH;;;;;;;;;;;;;GAaG;AACH;IAEI;;OAEG;IACH,mBAEC;IAED;;;OAGG;IACH,yBAEC;IAED;;;;;;OAMG;IACH,eAHW,gBAAgB,YAChB,IAAI,MAAM,EAAE,kBAAkB,CAAC,QAIzC;IAED;;OAEG;IACH,uBAFW,WAAW,EAAE,QAIvB;IAED;;;;;;;;OAQG;IACH,wBAFW,YAAY,EAAE,QAIxB;IAED;;;;OAIG;IACH,aAJW,MAAM,EAAE,GAAC,YAAY,UACrB,MAAM,QACN,MAAM,QAIhB;IAED;;OAEG;IACH,SAFa,sBAAsB,CAIlC;IAED;;;OAGG;IACH,cAHW,sBAAsB,GACpB,OAAO,CAInB;IAED;;OAEG;IACH,QAFa,MAAM,CAIlB;CACJ;yCApGY,OAAO,iCAAiC,EAAE,0BAA0B;+BACpE,OAAO,wBAAwB,EAAE,gBAAgB;iCACjD,OAAO,iCAAiC,EAAE,kBAAkB;0BAC5D,OAAO,mBAAmB,EAAE,WAAW;2BACvC,OAAO,4BAA4B,EAAE,YAAY;qBACjD,OAAO,sCAAsC,EAAE,MAAM"}

package/src/engine/input/ecs/ism/coordinate/InputCoordinateChannel.js

@@ -1,3 +1,12 @@
+/**
+ * @typedef {import('./InputCoordinateChannelType.js').InputCoordinateChannelType} InputCoordinateChannelType
+ * @typedef {import('../InputSourceTable.js').InputSourceTable} InputSourceTable
+ * @typedef {import('../device/InputDeviceAdapter.js').InputDeviceAdapter} InputDeviceAdapter
+ * @typedef {import('../InputSource.js').InputSource} InputSource
+ * @typedef {import('../trigger/InputTrigger.js').InputTrigger} InputTrigger
+ * @typedef {import('../../../../../core/binary/BitSet.js').BitSet} BitSet
+ */
+
 /**
  * An N-dimensional analog channel an action can be bound to.
  *

package/src/engine/input/ecs/ism/coordinate/InputCoordinateDevice.d.ts

@@ -1,3 +1,8 @@
+/**
+ * @typedef {import('../InputSourceTable.js').InputSourceTable} InputSourceTable
+ * @typedef {import('../device/InputDeviceAdapter.js').InputDeviceAdapter} InputDeviceAdapter
+ * @typedef {import('../../../../../core/binary/BitSet.js').BitSet} BitSet
+ */
 /**
  * A channel read straight from a device.
  *
@@ -23,6 +28,13 @@ export class InputCoordinateDevice extends InputCoordinateChannel {
      * @returns {InputCoordinateDevice}
      */
     static fromGamepad(code: number): InputCoordinateDevice;
+    /**
+     * Select/squeeze and raw buttons/axes are scalar; thumbstick/touchpad have two components.
+     * @param {'left'|'right'|'none'} handedness
+     * @param {number} code XRInputCoordinates or xr_input_button_coordinate/xr_input_axis_coordinate.
+     * @returns {InputCoordinateDevice}
+     */
+    static fromXR(handedness: 'left' | 'right' | 'none', code: number): InputCoordinateDevice;
     /**
      * A pointer channel. `position` is 2-D absolute; `move` is 2-D and `wheel` is 3-D, both relative and
      * both LATCHED once per frame - a reader sees the total that arrived since the previous frame, and sees
@@ -36,16 +48,15 @@ export class InputCoordinateDevice extends InputCoordinateChannel {
      * @type {InputCoordinateSource}
      */
     source: InputCoordinateSource;
-    /**
-     * @returns {InputCoordinateChannelType}
-     */
-    get type(): number;
     /**
      * @returns {InputCoordinateDevice}
      */
     clone(): InputCoordinateDevice;
     #private;
 }
+export type InputSourceTable = import('../InputSourceTable.js').InputSourceTable;
+export type InputDeviceAdapter = import('../device/InputDeviceAdapter.js').InputDeviceAdapter;
+export type BitSet = import('../../../../../core/binary/BitSet.js').BitSet;
 import { InputCoordinateChannel } from "./InputCoordinateChannel.js";
 import { InputCoordinateSource } from "../InputCoordinateSource.js";
 //# sourceMappingURL=InputCoordinateDevice.d.ts.map

package/src/engine/input/ecs/ism/coordinate/InputCoordinateDevice.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"InputCoordinateDevice.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/input/ecs/ism/coordinate/InputCoordinateDevice.js"],"names":[],"mappings":"AAWA;;;;;;;;;;;GAWG;AACH;IA2BI;;;OAGG;IACH,0BAHW,qBAAqB,GACnB,qBAAqB,CAUjC;IAED;;;;;OAKG;IACH,yBAHW,MAAM,GACJ,qBAAqB,CAQjC;IAED;;;;;;;OAOG;IACH,yBAHW,MAAM,GACJ,qBAAqB,CAajC;IAxED;;OAEG;IACH,QAFU,qBAAqB,CAEM;IAQrC;;OAEG;IACH,mBAEC;IAyFD;;OAEG;IACH,SAFa,qBAAqB,CAIjC;;CAiBJ;uCAjJsC,6BAA6B;sCAD9B,6BAA6B"}
+{"version":3,"file":"InputCoordinateDevice.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/input/ecs/ism/coordinate/InputCoordinateDevice.js"],"names":[],"mappings":"AAaA;;;;GAIG;AAEH;;;;;;;;;;;GAWG;AACH;IA2BI;;;OAGG;IACH,0BAHW,qBAAqB,GACnB,qBAAqB,CAUjC;IAED;;;;;OAKG;IACH,yBAHW,MAAM,GACJ,qBAAqB,CAQjC;IAED;;;;;OAKG;IACH,0BAJW,MAAM,GAAC,OAAO,GAAC,MAAM,QACrB,MAAM,GACJ,qBAAqB,CAQjC;IAED;;;;;;;OAOG;IACH,yBAHW,MAAM,GACJ,qBAAqB,CAajC;IAtFD;;OAEG;IACH,QAFU,qBAAqB,CAEM;IAoHrC;;OAEG;IACH,SAFa,qBAAqB,CAIjC;;CAiBJ;+BAhKY,OAAO,wBAAwB,EAAE,gBAAgB;iCACjD,OAAO,iCAAiC,EAAE,kBAAkB;qBAC5D,OAAO,sCAAsC,EAAE,MAAM;uCAP3B,6BAA6B;sCAD9B,6BAA6B"}