@codexo/exojs 0.7.12 → 0.7.13

package/dist/exo.esm.js

@@ -5592,7 +5592,7 @@ class SceneManager {
         return { updateScenes, drawScenes };
     }
     _subscribeInputRouting() {
-        const inputManager = this._app.inputManager;
+        const inputManager = this._app.input;
         inputManager?.onKeyDown?.add?.(this._handleKeyDown);
         inputManager?.onKeyUp?.add?.(this._handleKeyUp);
         inputManager?.onPointerEnter?.add?.(this._handlePointerEnter);
@@ -5606,7 +5606,7 @@ class SceneManager {
         inputManager?.onMouseWheel?.add?.(this._handleMouseWheel);
     }
     _unsubscribeInputRouting() {
-        const inputManager = this._app.inputManager;
+        const inputManager = this._app.input;
         inputManager?.onKeyDown?.remove?.(this._handleKeyDown);
         inputManager?.onKeyUp?.remove?.(this._handleKeyUp);
         inputManager?.onPointerEnter?.remove?.(this._handlePointerEnter);
@@ -12919,85 +12919,6 @@ var ChannelOffset;
 const maxPointers = 16;
 /** Number of channel slots reserved per pointer. 16 pointers × 16 slots = 256 (fills the Pointers category exactly). */
 const pointerSlotSize = 16;
-/**
- * Channel offsets for unified pointer (mouse / touch / pen) state.
- *
- * The un-prefixed aliases (Active, X, Y, …) are identical to Slot0Active, Slot0X, Slot0Y, …
- * and address the primary pointer (slot 0). Use Slot{N}Active / Slot{N}X / Slot{N}Y for
- * multi-pointer (e.g. pinch) access. Other per-slot channels beyond Active/X/Y are reachable
- * via arithmetic: `Pointer.X + slotIndex * pointerSlotSize + channelOffset` (Pointer.X = PointerChannel.X).
- *
- * @internal — accessed publicly via the `Pointer` class namespace (see Pointer.ts).
- */
-var PointerChannel;
-(function (PointerChannel) {
-    // --- Convenience aliases for the primary pointer (slot 0) ---
-    PointerChannel[PointerChannel["Active"] = 256] = "Active";
-    PointerChannel[PointerChannel["X"] = 257] = "X";
-    PointerChannel[PointerChannel["Y"] = 258] = "Y";
-    PointerChannel[PointerChannel["Pressure"] = 259] = "Pressure";
-    PointerChannel[PointerChannel["Width"] = 260] = "Width";
-    PointerChannel[PointerChannel["Height"] = 261] = "Height";
-    PointerChannel[PointerChannel["Twist"] = 262] = "Twist";
-    PointerChannel[PointerChannel["TiltX"] = 263] = "TiltX";
-    PointerChannel[PointerChannel["TiltY"] = 264] = "TiltY";
-    PointerChannel[PointerChannel["Left"] = 265] = "Left";
-    PointerChannel[PointerChannel["Right"] = 266] = "Right";
-    PointerChannel[PointerChannel["Middle"] = 267] = "Middle";
-    PointerChannel[PointerChannel["IsMouse"] = 268] = "IsMouse";
-    PointerChannel[PointerChannel["IsTouch"] = 269] = "IsTouch";
-    PointerChannel[PointerChannel["IsPen"] = 270] = "IsPen";
-    PointerChannel[PointerChannel["IsPrimary"] = 271] = "IsPrimary";
-    // --- Per-slot Active/X/Y for multi-pointer access ---
-    PointerChannel[PointerChannel["Slot0Active"] = 256] = "Slot0Active";
-    PointerChannel[PointerChannel["Slot0X"] = 257] = "Slot0X";
-    PointerChannel[PointerChannel["Slot0Y"] = 258] = "Slot0Y";
-    PointerChannel[PointerChannel["Slot1Active"] = 272] = "Slot1Active";
-    PointerChannel[PointerChannel["Slot1X"] = 273] = "Slot1X";
-    PointerChannel[PointerChannel["Slot1Y"] = 274] = "Slot1Y";
-    PointerChannel[PointerChannel["Slot2Active"] = 288] = "Slot2Active";
-    PointerChannel[PointerChannel["Slot2X"] = 289] = "Slot2X";
-    PointerChannel[PointerChannel["Slot2Y"] = 290] = "Slot2Y";
-    PointerChannel[PointerChannel["Slot3Active"] = 304] = "Slot3Active";
-    PointerChannel[PointerChannel["Slot3X"] = 305] = "Slot3X";
-    PointerChannel[PointerChannel["Slot3Y"] = 306] = "Slot3Y";
-    PointerChannel[PointerChannel["Slot4Active"] = 320] = "Slot4Active";
-    PointerChannel[PointerChannel["Slot4X"] = 321] = "Slot4X";
-    PointerChannel[PointerChannel["Slot4Y"] = 322] = "Slot4Y";
-    PointerChannel[PointerChannel["Slot5Active"] = 336] = "Slot5Active";
-    PointerChannel[PointerChannel["Slot5X"] = 337] = "Slot5X";
-    PointerChannel[PointerChannel["Slot5Y"] = 338] = "Slot5Y";
-    PointerChannel[PointerChannel["Slot6Active"] = 352] = "Slot6Active";
-    PointerChannel[PointerChannel["Slot6X"] = 353] = "Slot6X";
-    PointerChannel[PointerChannel["Slot6Y"] = 354] = "Slot6Y";
-    PointerChannel[PointerChannel["Slot7Active"] = 368] = "Slot7Active";
-    PointerChannel[PointerChannel["Slot7X"] = 369] = "Slot7X";
-    PointerChannel[PointerChannel["Slot7Y"] = 370] = "Slot7Y";
-    PointerChannel[PointerChannel["Slot8Active"] = 384] = "Slot8Active";
-    PointerChannel[PointerChannel["Slot8X"] = 385] = "Slot8X";
-    PointerChannel[PointerChannel["Slot8Y"] = 386] = "Slot8Y";
-    PointerChannel[PointerChannel["Slot9Active"] = 400] = "Slot9Active";
-    PointerChannel[PointerChannel["Slot9X"] = 401] = "Slot9X";
-    PointerChannel[PointerChannel["Slot9Y"] = 402] = "Slot9Y";
-    PointerChannel[PointerChannel["Slot10Active"] = 416] = "Slot10Active";
-    PointerChannel[PointerChannel["Slot10X"] = 417] = "Slot10X";
-    PointerChannel[PointerChannel["Slot10Y"] = 418] = "Slot10Y";
-    PointerChannel[PointerChannel["Slot11Active"] = 432] = "Slot11Active";
-    PointerChannel[PointerChannel["Slot11X"] = 433] = "Slot11X";
-    PointerChannel[PointerChannel["Slot11Y"] = 434] = "Slot11Y";
-    PointerChannel[PointerChannel["Slot12Active"] = 448] = "Slot12Active";
-    PointerChannel[PointerChannel["Slot12X"] = 449] = "Slot12X";
-    PointerChannel[PointerChannel["Slot12Y"] = 450] = "Slot12Y";
-    PointerChannel[PointerChannel["Slot13Active"] = 464] = "Slot13Active";
-    PointerChannel[PointerChannel["Slot13X"] = 465] = "Slot13X";
-    PointerChannel[PointerChannel["Slot13Y"] = 466] = "Slot13Y";
-    PointerChannel[PointerChannel["Slot14Active"] = 480] = "Slot14Active";
-    PointerChannel[PointerChannel["Slot14X"] = 481] = "Slot14X";
-    PointerChannel[PointerChannel["Slot14Y"] = 482] = "Slot14Y";
-    PointerChannel[PointerChannel["Slot15Active"] = 496] = "Slot15Active";
-    PointerChannel[PointerChannel["Slot15X"] = 497] = "Slot15X";
-    PointerChannel[PointerChannel["Slot15Y"] = 498] = "Slot15Y";
-})(PointerChannel || (PointerChannel = {}));
 /**
  * Channel indices for keyboard keys, derived from the legacy `KeyboardEvent.keyCode`
  * map. Pass any value to the {@link Input} constructor to react to that key.
@@ -13111,197 +13032,484 @@ var Keyboard;
 })(Keyboard || (Keyboard = {}));
 
 /**
- * Runtime wrapper for a single browser gamepad slot.
+ * {@link Clock} variant with a fixed limit. Inherits start/stop/reset/restart
+ * semantics; adds {@link Timer.expired} (true once `elapsedTime >= limit`)
+ * and remaining-time accessors. Useful for cooldowns, delays, and any timed
+ * gating logic where you want to ask "is the duration up?" each frame.
+ */
+class Timer extends Clock {
+    _limit;
+    constructor(limit, autoStart = false) {
+        super();
+        this._limit = limit.clone();
+        if (autoStart) {
+            this.restart();
+        }
+    }
+    set limit(limit) {
+        this._limit.copy(limit);
+    }
+    /** `true` once the elapsed time has reached or exceeded the configured limit. */
+    get expired() {
+        return this.elapsedMilliseconds >= this._limit.milliseconds;
+    }
+    get remainingMilliseconds() {
+        return Math.max(0, this._limit.milliseconds - this.elapsedMilliseconds);
+    }
+    get remainingSeconds() {
+        return this.remainingMilliseconds / Time.seconds;
+    }
+    get remainingMinutes() {
+        return this.remainingMilliseconds / Time.minutes;
+    }
+    get remainingHours() {
+        return this.remainingMilliseconds / Time.hours;
+    }
+}
+
+/**
+ * One subscription to one or more input channels. Tracks active state, fires
+ * the {@link onStart} / {@link onActive} / {@link onStop} / {@link onTrigger}
+ * Signals each frame, and registers itself with whichever owner created it
+ * (typically an {@link InputManager}, {@link Gamepad}, or scene-bound
+ * proxy).
+ *
+ * Construct via the owner's `onStart` / `onActive` / `onStop` /
+ * `onTrigger` factory methods rather than `new InputBinding(...)` directly.
  *
- * Owns the slot's {@link GamepadMapping}, reads raw button and axis values from
- * the browser's Gamepad API each frame via {@link update}, and writes transformed
- * values into the shared `Float32Array` channel buffer. Emits {@link onConnect},
- * {@link onDisconnect}, and per-channel {@link onUpdate} signals so consumers can
- * react without polling.
+ * Lifecycle: a binding lives until {@link unbind} is called, the owner
+ * disposes it, or — for scene-bound bindings — the scene unloads.
+ *
+ * @internal
+ */
+class InputBinding {
+    /**
+     * Default tap-window for `onTrigger`. Override per binding via the
+     * `threshold` option. Mutating this static affects only newly created
+     * bindings.
+     */
+    static defaultTriggerThreshold = 300;
+    channels;
+    onStart = new Signal();
+    onActive = new Signal();
+    onStop = new Signal();
+    onTrigger = new Signal();
+    _triggerTimer;
+    _detacher;
+    _value = 0;
+    _unbound = false;
+    constructor(channels, options = {}, detacher = null) {
+        this.channels = channels;
+        this._triggerTimer = new Timer(milliseconds(options.threshold ?? InputBinding.defaultTriggerThreshold));
+        this._detacher = detacher;
+    }
+    /** Last value sampled this frame. 0 when inactive. */
+    get value() {
+        return this._value;
+    }
+    /** `true` when the last sampled value exceeded the channel's threshold. */
+    get active() {
+        return this._value > 0;
+    }
+    /**
+     * Read the latest values from the unified channel buffer and dispatch
+     * the appropriate Signals. Called once per frame by the owning manager.
+     *
+     * @internal
+     */
+    update(channels) {
+        if (this._unbound) {
+            return;
+        }
+        let value = 0;
+        for (const channel of this.channels) {
+            const sample = channels[channel];
+            if (Math.abs(sample) > Math.abs(value)) {
+                value = sample;
+            }
+        }
+        this._value = value;
+        if (value !== 0) {
+            if (!this._triggerTimer.running) {
+                this._triggerTimer.restart();
+                this.onStart.dispatch(value);
+            }
+            this.onActive.dispatch(value);
+        }
+        else if (this._triggerTimer.running) {
+            this.onStop.dispatch(0);
+            if (!this._triggerTimer.expired) {
+                this.onTrigger.dispatch(0);
+            }
+            this._triggerTimer.stop();
+        }
+    }
+    /**
+     * Detach this binding from its owner and release its Signals. Idempotent.
+     */
+    unbind() {
+        if (this._unbound) {
+            return;
+        }
+        this._unbound = true;
+        this._detacher?.detach(this);
+        this._triggerTimer.destroy();
+        this.onStart.destroy();
+        this.onActive.destroy();
+        this.onStop.destroy();
+        this.onTrigger.destroy();
+    }
+}
+
+/**
+ * One of four stable gamepad slots. Lives for the entire `Application`
+ * lifetime even when no physical pad is attached — a "mailbox" that
+ * physical hardware moves into and out of.
+ *
+ * Subscribe to {@link onConnect} / {@link onDisconnect} for hardware
+ * lifecycle, {@link onButtonDown} / {@link onButtonUp} / {@link onAxisChange}
+ * for granular per-event notifications, or call {@link onTrigger} /
+ * {@link onActive} / {@link onStart} / {@link onStop} to register
+ * stateful {@link InputBinding}s pinned to this slot.
+ *
+ * Listeners survive disconnect/reconnect cycles — a binding registered when
+ * the slot was empty will automatically activate when a pad connects.
  */
 class Gamepad {
+    /** Fires when a physical pad connects to this slot. */
     onConnect = new Signal();
+    /** Fires when the physical pad in this slot disconnects. */
     onDisconnect = new Signal();
-    onUpdate = new Signal();
-    indexValue;
-    channelsValue;
-    channelOffset;
-    mappingValue;
-    browserGamepad = null;
-    info = {
-        name: 'Generic Gamepad',
-        label: 'Generic Gamepad',
-        vendorId: null,
-        productId: null,
-        productKey: null,
-    };
-    constructor(indexOrGamepad, channels, mappingOrDefinition) {
-        const isBrowserGamepad = typeof indexOrGamepad !== 'number';
-        const gamepad = isBrowserGamepad ? indexOrGamepad : null;
-        const index = isBrowserGamepad ? indexOrGamepad.index : indexOrGamepad;
-        this.indexValue = index;
-        this.channelsValue = channels;
-        this.channelOffset = ChannelOffset.Gamepads + (index * ChannelSize.Gamepad);
-        this.mappingValue = gamepad
-            ? mappingOrDefinition.mapping
-            : mappingOrDefinition;
-        if (gamepad) {
-            const definition = mappingOrDefinition;
-            this.setInfo({
-                name: definition.name,
-                label: definition.descriptor.label,
-                vendorId: definition.descriptor.vendorId,
-                productId: definition.descriptor.productId,
-                productKey: definition.descriptor.productKey,
-            });
-            this.connect(gamepad);
-        }
+    /** Fires for every button transition from inactive to active. */
+    onButtonDown = new Signal();
+    /** Fires for every button transition from active to inactive. */
+    onButtonUp = new Signal();
+    /** Fires whenever an axis crosses its activation threshold. */
+    onAxisChange = new Signal();
+    /**
+     * Fires when this slot's physical pad has been replaced by a previously
+     * higher-numbered slot's pad, after a `'compact'`-strategy disconnect.
+     * Dispatched with the source slot index the pad came from. Listeners
+     * remain attached and the channel buffer is preserved across the move.
+     */
+    onPadReassigned = new Signal();
+    _slot;
+    _channels;
+    _bindings = new Set();
+    _detacher = { detach: (binding) => { this._bindings.delete(binding); } };
+    _channelOffset;
+    _mapping = null;
+    _info = null;
+    _browserGamepad = null;
+    constructor(slot, channels) {
+        this._slot = slot;
+        this._channels = channels;
+        this._channelOffset = ChannelOffset.Gamepads + (slot * ChannelSize.Gamepad);
     }
-    get mapping() {
-        return this.mappingValue;
+    /** This pad's stable slot (0..3). */
+    get slot() {
+        return this._slot;
+    }
+    /** `true` while a physical pad is attached to this slot. */
+    get connected() {
+        return this._browserGamepad !== null;
     }
-    set mapping(mapping) {
-        this.mappingValue = mapping;
+    /** The active mapping, or `null` when disconnected. */
+    get mapping() {
+        return this._mapping;
     }
-    /** The {@link GamepadMappingFamily} of the currently active mapping. */
+    /** The {@link GamepadMappingFamily}, or `null` when disconnected. */
     get mappingFamily() {
-        return this.mappingValue.family;
+        return this._mapping?.family ?? null;
     }
-    get channels() {
-        return this.channelsValue;
+    /** Identity metadata, or `null` when disconnected. */
+    get info() {
+        return this._info;
     }
-    get gamepad() {
-        return this.browserGamepad;
+    /** The underlying browser gamepad object, or `null` when disconnected. */
+    get browserGamepad() {
+        return this._browserGamepad;
     }
-    get index() {
-        return this.indexValue;
+    /**
+     * Browser-assigned hardware index from `navigator.getGamepads()` (i.e.
+     * `Gamepad.index`), or `null` when no pad is attached. Stable for the
+     * lifetime of a single physical connection but may change across
+     * disconnect/reconnect. Low-level escape hatch for advanced consumers
+     * that need to correlate slots with the raw browser API; prefer
+     * {@link slot} for stable per-application pad identity.
+     */
+    get internalIndex() {
+        return this._browserGamepad?.index ?? null;
     }
-    /** Whether a browser gamepad is currently attached to this slot. */
-    get connected() {
-        return this.browserGamepad !== null;
+    /** `true` when the connected pad supports rumble via the Web Gamepad API. */
+    get canVibrate() {
+        return this._browserGamepad?.vibrationActuator != null;
+    }
+    /**
+     * Returns `true` when this pad's mapping declares the requested channel.
+     * Use to gate listener registration on optional hardware (e.g. Joy-Con
+     * solo lacks a right stick — `pad.hasChannel(GamepadAxis.RightStickX)`
+     * returns `false`).
+     */
+    hasChannel(channel) {
+        return this._mapping?.hasChannel(channel) ?? false;
+    }
+    /**
+     * Trigger a rumble effect on this pad. Resolves when the effect finishes.
+     * Silent no-op when the pad is disconnected or the platform does not
+     * support haptic feedback. Use {@link canVibrate} to detect support.
+     */
+    async vibrate(options) {
+        const actuator = this._browserGamepad?.vibrationActuator;
+        if (!actuator?.playEffect) {
+            return;
+        }
+        await actuator.playEffect('dual-rumble', {
+            duration: options.duration,
+            weakMagnitude: options.weakMagnitude ?? 1,
+            strongMagnitude: options.strongMagnitude ?? 1,
+            startDelay: options.startDelay ?? 0,
+        });
     }
-    get name() {
-        return this.info.name;
+    /** Stop any active rumble on this pad. Silent no-op when unsupported. */
+    stopVibration() {
+        this._browserGamepad?.vibrationActuator?.reset?.();
     }
-    get label() {
-        return this.info.label;
+    /**
+     * Register a callback fired once when any of `channels` becomes active.
+     * Listener survives disconnect/reconnect; call `.unbind()` on the
+     * returned {@link InputBinding} to detach.
+     */
+    onStart(channel, callback, options) {
+        const binding = this._createBinding(channel, options);
+        binding.onStart.add(callback);
+        return binding;
     }
-    get vendorId() {
-        return this.info.vendorId;
+    /**
+     * Register a callback fired every frame while any of `channels` is active.
+     * Receives the channel value (0..1 for buttons, -1..1 for bipolar axes).
+     */
+    onActive(channel, callback, options) {
+        const binding = this._createBinding(channel, options);
+        binding.onActive.add(callback);
+        return binding;
     }
-    get productId() {
-        return this.info.productId;
+    /** Register a callback fired once when all of `channels` become inactive. */
+    onStop(channel, callback, options) {
+        const binding = this._createBinding(channel, options);
+        binding.onStop.add(callback);
+        return binding;
     }
-    get productKey() {
-        return this.info.productKey;
+    /**
+     * Register a callback fired when the input is released within
+     * {@link InputBindingOptions.threshold} ms of activation (a "tap").
+     */
+    onTrigger(channel, callback, options) {
+        const binding = this._createBinding(channel, options);
+        binding.onTrigger.add(callback);
+        return binding;
     }
     /**
-     * Replaces the gamepad's identity metadata.
-     * Called automatically during construction when a {@link BrowserGamepad} is
-     * provided; exposed publicly to allow runtime overrides.
+     * Attach a physical browser gamepad to this slot. Called by
+     * {@link InputManager} on connect.
+     *
+     * @internal
      */
-    setInfo(info) {
-        this.info = info;
-        return this;
+    _bind(gamepad, definition) {
+        this._browserGamepad = gamepad;
+        this._mapping = definition.mapping;
+        this._info = {
+            name: definition.name,
+            label: definition.descriptor.label,
+            vendorId: definition.descriptor.vendorId,
+            productId: definition.descriptor.productId,
+            productKey: definition.descriptor.productKey,
+        };
+        this.onConnect.dispatch();
     }
     /**
-     * Attaches a live browser gamepad to this slot and dispatches {@link onConnect}
-     * if the slot was previously disconnected.
+     * Detach the physical gamepad and clear its channels.
+     *
+     * @internal
      */
-    connect(gamepad) {
-        const wasConnected = this.connected;
-        this.browserGamepad = gamepad;
-        if (!wasConnected) {
-            this.onConnect.dispatch(this);
+    _unbind() {
+        if (this._browserGamepad === null) {
+            return;
         }
-        return this;
+        this._clearMappedChannels();
+        this._browserGamepad = null;
+        this._mapping = null;
+        this._info = null;
+        this.onDisconnect.dispatch();
     }
     /**
-     * Detaches the browser gamepad, zeros all mapped channels, and dispatches
-     * {@link onDisconnect}. No-op when already disconnected.
+     * Detach the physical gamepad and clear channels without firing
+     * {@link onDisconnect}. Used by {@link InputManager} during the compact
+     * slot-shift to silently vacate a slot before another pad shifts into
+     * its place; the disconnect signal is fired separately on the slot that
+     * ends up empty after compaction.
+     *
+     * @internal
      */
-    disconnect() {
-        if (this.connected) {
-            this.browserGamepad = null;
-            this.clearMappedChannels();
-            this.onDisconnect.dispatch(this);
+    _silentUnbind() {
+        if (this._browserGamepad === null) {
+            return;
         }
-        return this;
+        this._clearMappedChannels();
+        this._browserGamepad = null;
+        this._mapping = null;
+        this._info = null;
     }
     /**
-     * Samples the browser gamepad's current state and writes transformed values
-     * into the shared channel buffer, dispatching {@link onUpdate} for each channel
-     * whose value changed. Should be called once per frame by the engine's input loop.
-     * No-op when disconnected.
+     * Dispatch this slot's {@link onDisconnect} signal without altering its
+     * state. Used by {@link InputManager} after a compact-mode shift, when a
+     * slot has already been emptied by {@link _rebindFrom} and now needs to
+     * notify subscribers that its mailbox is no longer occupied.
+     *
+     * @internal
+     */
+    _dispatchDisconnect() {
+        this.onDisconnect.dispatch();
+    }
+    /**
+     * Reassign this slot to take over another slot's physical gamepad without
+     * firing the full disconnect / connect cycle. Used by {@link InputManager}
+     * when the `'compact'` slot strategy shuffles pads after a disconnect.
+     *
+     * @internal
+     */
+    _rebindFrom(other) {
+        const gamepad = other._browserGamepad;
+        const mapping = other._mapping;
+        const info = other._info;
+        this._clearMappedChannels();
+        other._clearMappedChannels();
+        other._browserGamepad = null;
+        other._mapping = null;
+        other._info = null;
+        this._browserGamepad = gamepad;
+        this._mapping = mapping;
+        this._info = info;
+    }
+    /**
+     * Sample the browser gamepad's current state and write transformed values
+     * into the shared channel buffer, dispatching transition events when
+     * channel activity crosses thresholds. Called once per frame by the
+     * engine's input loop. No-op when disconnected.
+     *
+     * @internal
      */
     update() {
-        if (this.browserGamepad === null) {
-            return this;
+        if (this._browserGamepad === null || this._mapping === null) {
+            this._updateBindings();
+            return;
         }
-        const channels = this.channelsValue;
-        const { buttons: gamepadButtons, axes: gamepadAxes } = this.browserGamepad;
-        for (const control of this.mappingValue.buttons) {
-            const offsetChannel = this.resolveChannelOffset(control.channel);
-            if (control.index < gamepadButtons.length) {
-                const value = control.transformValue(gamepadButtons[control.index].value) || 0;
-                if (channels[offsetChannel] !== value) {
-                    channels[offsetChannel] = value;
-                    this.onUpdate.dispatch(control.channel, value, this);
-                }
+        const channels = this._channels;
+        const { buttons: rawButtons, axes: rawAxes } = this._browserGamepad;
+        for (const button of this._mapping.buttons) {
+            if (button.index >= rawButtons.length) {
+                continue;
+            }
+            const offset = this._resolveOffset(button.channel);
+            const previous = channels[offset];
+            const value = button.transformValue(rawButtons[button.index].value) || 0;
+            if (previous === value) {
+                continue;
+            }
+            channels[offset] = value;
+            if (previous === 0 && value !== 0) {
+                this.onButtonDown.dispatch(button, value);
+            }
+            else if (previous !== 0 && value === 0) {
+                this.onButtonUp.dispatch(button, value);
             }
         }
-        for (const control of this.mappingValue.axes) {
-            const offsetChannel = this.resolveChannelOffset(control.channel);
-            if (control.index < gamepadAxes.length) {
-                const value = control.transformValue(gamepadAxes[control.index]) || 0;
-                if (channels[offsetChannel] !== value) {
-                    channels[offsetChannel] = value;
-                    this.onUpdate.dispatch(control.channel, value, this);
-                }
+        for (const axis of this._mapping.axes) {
+            if (axis.index >= rawAxes.length) {
+                continue;
             }
+            const offset = this._resolveOffset(axis.channel);
+            const previous = channels[offset];
+            const value = axis.transformValue(rawAxes[axis.index]) || 0;
+            if (previous === value) {
+                continue;
+            }
+            channels[offset] = value;
+            this.onAxisChange.dispatch(axis, value);
         }
-        return this;
-    }
-    /** Zeroes all channel buffer entries that belong to this gamepad's mapping. */
-    clearChannels() {
-        this.clearMappedChannels();
-        return this;
+        this._updateBindings();
     }
     /**
-     * Disconnects the gamepad, clears its channels, and destroys all signals.
-     * The instance must not be used after this call.
+     * Tear down this gamepad slot. Called on application shutdown.
      */
     destroy() {
-        this.disconnect();
-        this.clearMappedChannels();
+        for (const binding of Array.from(this._bindings)) {
+            binding.unbind();
+        }
+        this._bindings.clear();
+        this._unbind();
         this.onConnect.destroy();
         this.onDisconnect.destroy();
-        this.onUpdate.destroy();
+        this.onButtonDown.destroy();
+        this.onButtonUp.destroy();
+        this.onAxisChange.destroy();
+        this.onPadReassigned.destroy();
     }
     /**
-     * Converts a {@link GamepadChannel} to its absolute index in the shared channel
-     * buffer for this gamepad instance.
+     * Convert a slot-relative channel value to its absolute index in the
+     * shared channel buffer for this slot.
      */
     resolveChannelOffset(channel) {
-        return this.channelOffset + (channel ^ ChannelOffset.Gamepads);
+        return this._resolveOffset(channel);
     }
     /**
-     * Converts a gamepad slot index and {@link GamepadChannel} to an absolute
-     * channel buffer offset without requiring a {@link Gamepad} instance.
+     * Static counterpart to {@link Gamepad.resolveChannelOffset} — resolves
+     * an absolute channel-buffer offset for a given slot index without
+     * requiring a Gamepad instance.
      */
-    static resolveChannelOffset(gamepadIndex, channel) {
-        return ChannelOffset.Gamepads + (gamepadIndex * ChannelSize.Gamepad) + (channel ^ ChannelOffset.Gamepads);
+    static resolveChannelOffset(slot, channel) {
+        return ChannelOffset.Gamepads + (slot * ChannelSize.Gamepad) + (channel ^ ChannelOffset.Gamepads);
     }
-    clearMappedChannels() {
-        for (const control of this.mappingValue.buttons) {
-            this.channelsValue[this.resolveChannelOffset(control.channel)] = 0;
+    _resolveOffset(channel) {
+        return this._channelOffset + (channel ^ ChannelOffset.Gamepads);
+    }
+    _clearMappedChannels() {
+        if (this._mapping === null) {
+            return;
         }
-        for (const control of this.mappingValue.axes) {
-            this.channelsValue[this.resolveChannelOffset(control.channel)] = 0;
+        for (const button of this._mapping.buttons) {
+            this._channels[this._resolveOffset(button.channel)] = 0;
+        }
+        for (const axis of this._mapping.axes) {
+            this._channels[this._resolveOffset(axis.channel)] = 0;
+        }
+    }
+    _createBinding(channel, options = {}) {
+        const list = Array.isArray(channel) ? channel : [channel];
+        const resolved = list.map((c) => this._resolveExternalChannel(c));
+        const binding = new InputBinding(resolved, options, this._detacher);
+        this._bindings.add(binding);
+        return binding;
+    }
+    _resolveExternalChannel(channel) {
+        // Keyboard channels are global (no slot offset). Gamepad channels
+        // need slot-aware translation. Any channel value within the
+        // gamepad-section maps through this pad's slot offset; others
+        // (Keyboard, Pointer) pass through as-is.
+        if (channel >= ChannelOffset.Gamepads && channel < ChannelOffset.Gamepads + ChannelSize.Category) {
+            return this._resolveOffset(channel);
+        }
+        return channel;
+    }
+    _updateBindings() {
+        for (const binding of this._bindings) {
+            binding.update(this._channels);
         }
     }
 }
 
+const pointerCh = (offset) => (ChannelOffset.Pointers + offset);
+const slot = (s, field) => pointerCh(s * pointerSlotSize + field);
 /**
  * Bit flags accumulated on a {@link Pointer} between frames so consumers can
  * detect transient events (entered the canvas, was released, was cancelled)
@@ -13525,82 +13733,80 @@ class Pointer {
     }
 }
 /**
- * Namespace merged onto the `Pointer` class to expose channel-offset constants.
- * All members mirror `PointerChannel` so callers can write `Pointer.Active`, `Pointer.X`, etc.
- *
- * The un-prefixed members (Active, X, Y, …) address slot 0 (the primary pointer).
- * For multi-touch access use `Pointer.Slot{N}Active / Slot{N}X / Slot{N}Y`, or compute:
- * `Pointer.X + slotIndex * pointerSlotSize + channelOffset`.
+ * Channel-identifier constants merged onto the `Pointer` class. The
+ * un-prefixed members (Active, X, Y, …) address slot 0 (the primary
+ * pointer). For multi-touch access use `Pointer.Slot{N}Active /
+ * Slot{N}X / Slot{N}Y`.
  */
 // eslint-disable-next-line @typescript-eslint/no-namespace
 (function (Pointer) {
     /* eslint-disable @typescript-eslint/naming-convention */
     // --- Primary-pointer convenience aliases (slot 0) ---
-    Pointer.Active = PointerChannel.Active;
-    Pointer.X = PointerChannel.X;
-    Pointer.Y = PointerChannel.Y;
-    Pointer.Pressure = PointerChannel.Pressure;
-    Pointer.Width = PointerChannel.Width;
-    Pointer.Height = PointerChannel.Height;
-    Pointer.Twist = PointerChannel.Twist;
-    Pointer.TiltX = PointerChannel.TiltX;
-    Pointer.TiltY = PointerChannel.TiltY;
-    Pointer.Left = PointerChannel.Left;
-    Pointer.Right = PointerChannel.Right;
-    Pointer.Middle = PointerChannel.Middle;
-    Pointer.IsMouse = PointerChannel.IsMouse;
-    Pointer.IsTouch = PointerChannel.IsTouch;
-    Pointer.IsPen = PointerChannel.IsPen;
-    Pointer.IsPrimary = PointerChannel.IsPrimary;
+    Pointer.Active = pointerCh(0);
+    Pointer.X = pointerCh(1);
+    Pointer.Y = pointerCh(2);
+    Pointer.Pressure = pointerCh(3);
+    Pointer.Width = pointerCh(4);
+    Pointer.Height = pointerCh(5);
+    Pointer.Twist = pointerCh(6);
+    Pointer.TiltX = pointerCh(7);
+    Pointer.TiltY = pointerCh(8);
+    Pointer.Left = pointerCh(9);
+    Pointer.Right = pointerCh(10);
+    Pointer.Middle = pointerCh(11);
+    Pointer.IsMouse = pointerCh(12);
+    Pointer.IsTouch = pointerCh(13);
+    Pointer.IsPen = pointerCh(14);
+    Pointer.IsPrimary = pointerCh(15);
     // --- Per-slot Active/X/Y for multi-pointer access ---
-    Pointer.Slot0Active = PointerChannel.Slot0Active;
-    Pointer.Slot0X = PointerChannel.Slot0X;
-    Pointer.Slot0Y = PointerChannel.Slot0Y;
-    Pointer.Slot1Active = PointerChannel.Slot1Active;
-    Pointer.Slot1X = PointerChannel.Slot1X;
-    Pointer.Slot1Y = PointerChannel.Slot1Y;
-    Pointer.Slot2Active = PointerChannel.Slot2Active;
-    Pointer.Slot2X = PointerChannel.Slot2X;
-    Pointer.Slot2Y = PointerChannel.Slot2Y;
-    Pointer.Slot3Active = PointerChannel.Slot3Active;
-    Pointer.Slot3X = PointerChannel.Slot3X;
-    Pointer.Slot3Y = PointerChannel.Slot3Y;
-    Pointer.Slot4Active = PointerChannel.Slot4Active;
-    Pointer.Slot4X = PointerChannel.Slot4X;
-    Pointer.Slot4Y = PointerChannel.Slot4Y;
-    Pointer.Slot5Active = PointerChannel.Slot5Active;
-    Pointer.Slot5X = PointerChannel.Slot5X;
-    Pointer.Slot5Y = PointerChannel.Slot5Y;
-    Pointer.Slot6Active = PointerChannel.Slot6Active;
-    Pointer.Slot6X = PointerChannel.Slot6X;
-    Pointer.Slot6Y = PointerChannel.Slot6Y;
-    Pointer.Slot7Active = PointerChannel.Slot7Active;
-    Pointer.Slot7X = PointerChannel.Slot7X;
-    Pointer.Slot7Y = PointerChannel.Slot7Y;
-    Pointer.Slot8Active = PointerChannel.Slot8Active;
-    Pointer.Slot8X = PointerChannel.Slot8X;
-    Pointer.Slot8Y = PointerChannel.Slot8Y;
-    Pointer.Slot9Active = PointerChannel.Slot9Active;
-    Pointer.Slot9X = PointerChannel.Slot9X;
-    Pointer.Slot9Y = PointerChannel.Slot9Y;
-    Pointer.Slot10Active = PointerChannel.Slot10Active;
-    Pointer.Slot10X = PointerChannel.Slot10X;
-    Pointer.Slot10Y = PointerChannel.Slot10Y;
-    Pointer.Slot11Active = PointerChannel.Slot11Active;
-    Pointer.Slot11X = PointerChannel.Slot11X;
-    Pointer.Slot11Y = PointerChannel.Slot11Y;
-    Pointer.Slot12Active = PointerChannel.Slot12Active;
-    Pointer.Slot12X = PointerChannel.Slot12X;
-    Pointer.Slot12Y = PointerChannel.Slot12Y;
-    Pointer.Slot13Active = PointerChannel.Slot13Active;
-    Pointer.Slot13X = PointerChannel.Slot13X;
-    Pointer.Slot13Y = PointerChannel.Slot13Y;
-    Pointer.Slot14Active = PointerChannel.Slot14Active;
-    Pointer.Slot14X = PointerChannel.Slot14X;
-    Pointer.Slot14Y = PointerChannel.Slot14Y;
-    Pointer.Slot15Active = PointerChannel.Slot15Active;
-    Pointer.Slot15X = PointerChannel.Slot15X;
-    Pointer.Slot15Y = PointerChannel.Slot15Y;
+    Pointer.Slot0Active = slot(0, 0);
+    Pointer.Slot0X = slot(0, 1);
+    Pointer.Slot0Y = slot(0, 2);
+    Pointer.Slot1Active = slot(1, 0);
+    Pointer.Slot1X = slot(1, 1);
+    Pointer.Slot1Y = slot(1, 2);
+    Pointer.Slot2Active = slot(2, 0);
+    Pointer.Slot2X = slot(2, 1);
+    Pointer.Slot2Y = slot(2, 2);
+    Pointer.Slot3Active = slot(3, 0);
+    Pointer.Slot3X = slot(3, 1);
+    Pointer.Slot3Y = slot(3, 2);
+    Pointer.Slot4Active = slot(4, 0);
+    Pointer.Slot4X = slot(4, 1);
+    Pointer.Slot4Y = slot(4, 2);
+    Pointer.Slot5Active = slot(5, 0);
+    Pointer.Slot5X = slot(5, 1);
+    Pointer.Slot5Y = slot(5, 2);
+    Pointer.Slot6Active = slot(6, 0);
+    Pointer.Slot6X = slot(6, 1);
+    Pointer.Slot6Y = slot(6, 2);
+    Pointer.Slot7Active = slot(7, 0);
+    Pointer.Slot7X = slot(7, 1);
+    Pointer.Slot7Y = slot(7, 2);
+    Pointer.Slot8Active = slot(8, 0);
+    Pointer.Slot8X = slot(8, 1);
+    Pointer.Slot8Y = slot(8, 2);
+    Pointer.Slot9Active = slot(9, 0);
+    Pointer.Slot9X = slot(9, 1);
+    Pointer.Slot9Y = slot(9, 2);
+    Pointer.Slot10Active = slot(10, 0);
+    Pointer.Slot10X = slot(10, 1);
+    Pointer.Slot10Y = slot(10, 2);
+    Pointer.Slot11Active = slot(11, 0);
+    Pointer.Slot11X = slot(11, 1);
+    Pointer.Slot11Y = slot(11, 2);
+    Pointer.Slot12Active = slot(12, 0);
+    Pointer.Slot12X = slot(12, 1);
+    Pointer.Slot12Y = slot(12, 2);
+    Pointer.Slot13Active = slot(13, 0);
+    Pointer.Slot13X = slot(13, 1);
+    Pointer.Slot13Y = slot(13, 2);
+    Pointer.Slot14Active = slot(14, 0);
+    Pointer.Slot14X = slot(14, 1);
+    Pointer.Slot14Y = slot(14, 2);
+    Pointer.Slot15Active = slot(15, 0);
+    Pointer.Slot15X = slot(15, 1);
+    Pointer.Slot15Y = slot(15, 2);
     /* eslint-enable @typescript-eslint/naming-convention */
 })(Pointer || (Pointer = {}));
 
@@ -13742,91 +13948,98 @@ class GestureRecognizer {
 }
 
 /**
- * Canonical channel identifiers for every control a standard gamepad can expose.
- *
- * Values are absolute offsets into the engine's shared {@link Float32Array} input
- * channel buffer — each member equals `ChannelOffset.Gamepads + localIndex`.
- * Use {@link Gamepad.resolveChannelOffset} to account for per-slot skew when
- * reading a specific gamepad's data.
+ * Single mappable button on a physical gamepad. Holds the raw browser
+ * `Gamepad.buttons[]` index, the canonical channel the value is written to,
+ * and the deadzone/inversion transform applied each frame by
+ * {@link transformValue}.
+ *
+ * Used by concrete {@link GamepadMapping} subclasses to declare a device's
+ * button layout. User code typically constructs these via
+ * `new GamepadButton(rawIndex, GamepadButton.South)` only when authoring a
+ * custom mapping.
+ *
+ * The static namespace exports (`GamepadButton.South`, `.East`, ...) carry
+ * the canonical channel offsets used to address each button.
  */
-var GamepadChannel;
-(function (GamepadChannel) {
-    GamepadChannel[GamepadChannel["ButtonSouth"] = 512] = "ButtonSouth";
-    GamepadChannel[GamepadChannel["ButtonWest"] = 513] = "ButtonWest";
-    GamepadChannel[GamepadChannel["ButtonEast"] = 514] = "ButtonEast";
-    GamepadChannel[GamepadChannel["ButtonNorth"] = 515] = "ButtonNorth";
-    GamepadChannel[GamepadChannel["LeftShoulder"] = 516] = "LeftShoulder";
-    GamepadChannel[GamepadChannel["RightShoulder"] = 517] = "RightShoulder";
-    GamepadChannel[GamepadChannel["LeftTrigger"] = 518] = "LeftTrigger";
-    GamepadChannel[GamepadChannel["RightTrigger"] = 519] = "RightTrigger";
-    GamepadChannel[GamepadChannel["Select"] = 520] = "Select";
-    GamepadChannel[GamepadChannel["Start"] = 521] = "Start";
-    GamepadChannel[GamepadChannel["LeftStick"] = 522] = "LeftStick";
-    GamepadChannel[GamepadChannel["RightStick"] = 523] = "RightStick";
-    GamepadChannel[GamepadChannel["DPadUp"] = 524] = "DPadUp";
-    GamepadChannel[GamepadChannel["DPadDown"] = 525] = "DPadDown";
-    GamepadChannel[GamepadChannel["DPadLeft"] = 526] = "DPadLeft";
-    GamepadChannel[GamepadChannel["DPadRight"] = 527] = "DPadRight";
-    GamepadChannel[GamepadChannel["Guide"] = 528] = "Guide";
-    GamepadChannel[GamepadChannel["Share"] = 529] = "Share";
-    GamepadChannel[GamepadChannel["Capture"] = 530] = "Capture";
-    GamepadChannel[GamepadChannel["Touchpad"] = 531] = "Touchpad";
-    GamepadChannel[GamepadChannel["Paddle1"] = 532] = "Paddle1";
-    GamepadChannel[GamepadChannel["LeftStickLeft"] = 533] = "LeftStickLeft";
-    GamepadChannel[GamepadChannel["LeftStickRight"] = 534] = "LeftStickRight";
-    GamepadChannel[GamepadChannel["LeftStickUp"] = 535] = "LeftStickUp";
-    GamepadChannel[GamepadChannel["LeftStickDown"] = 536] = "LeftStickDown";
-    GamepadChannel[GamepadChannel["RightStickLeft"] = 537] = "RightStickLeft";
-    GamepadChannel[GamepadChannel["RightStickRight"] = 538] = "RightStickRight";
-    GamepadChannel[GamepadChannel["RightStickUp"] = 539] = "RightStickUp";
-    GamepadChannel[GamepadChannel["RightStickDown"] = 540] = "RightStickDown";
-    GamepadChannel[GamepadChannel["AuxiliaryAxis0Negative"] = 541] = "AuxiliaryAxis0Negative";
-    GamepadChannel[GamepadChannel["AuxiliaryAxis0Positive"] = 542] = "AuxiliaryAxis0Positive";
-    GamepadChannel[GamepadChannel["AuxiliaryAxis1Negative"] = 543] = "AuxiliaryAxis1Negative";
-    GamepadChannel[GamepadChannel["AuxiliaryAxis1Positive"] = 544] = "AuxiliaryAxis1Positive";
-    GamepadChannel[GamepadChannel["AuxiliaryAxis2Negative"] = 545] = "AuxiliaryAxis2Negative";
-    GamepadChannel[GamepadChannel["AuxiliaryAxis2Positive"] = 546] = "AuxiliaryAxis2Positive";
-    GamepadChannel[GamepadChannel["AuxiliaryAxis3Negative"] = 547] = "AuxiliaryAxis3Negative";
-    GamepadChannel[GamepadChannel["AuxiliaryAxis3Positive"] = 548] = "AuxiliaryAxis3Positive";
-})(GamepadChannel || (GamepadChannel = {}));
-
-/**
- * Represents a single mappable control — one button or one axis — on a physical gamepad.
- *
- * Stores the raw Gamepad API `index`, the target {@link GamepadChannel}, and the
- * transform parameters (`invert`, `normalize`, `threshold`) applied each frame
- * by {@link transformValue} before the value is written to the channel buffer.
- */
-class GamepadControl {
+class GamepadButton {
     index;
     channel;
     invert;
-    normalize;
     threshold;
     constructor(index, channel, options = {}) {
         this.index = index;
         this.channel = channel;
         this.invert = options.invert ?? false;
-        this.normalize = options.normalize ?? false;
         this.threshold = clamp(options.threshold ?? 0.2, 0, 1);
     }
     /**
-     * Applies the control's transform pipeline to a raw browser value.
+     * Apply the button's transform pipeline to a raw browser button value
+     * (typically `Gamepad.buttons[i].value`, in 0..1).
      *
-     * Pipeline: clamp to [-1, 1] → optional invert → optional normalize to [0, 1]
-     * → dead-zone (returns 0 when the absolute result is at or below `threshold`).
+     * Pipeline: clamp to [0, 1] → optional invert → deadzone (returns 0 when
+     * the result is at or below `threshold`).
      */
     transformValue(value) {
-        let result = clamp(value, -1, 1);
+        let result = clamp(value, 0, 1);
         if (this.invert) {
-            result *= -1;
-        }
-        if (this.normalize) {
-            result = (result + 1) / 2;
+            result = 1 - result;
         }
         return result > this.threshold ? result : 0;
     }
 }
+const button = (offset) => (ChannelOffset.Gamepads + offset);
+/* eslint-disable @typescript-eslint/no-namespace, @typescript-eslint/naming-convention */
+/**
+ * Channel-identifier constants — same convention as `Pointer.X` /
+ * `Keyboard.Space`. The first 32 slots of each gamepad sub-buffer are
+ * reserved for buttons (24 named, 8 buffer for future / custom mappings).
+ */
+(function (GamepadButton) {
+    /** Bottom face button. Xbox=A, PlayStation=✕, Switch (horizontal Joy-Con)=B. Conventional usage: confirm / primary action / jump. */
+    GamepadButton.South = button(0);
+    /** Right face button. Xbox=B, PlayStation=○, Switch=A. Conventional usage: cancel / back / secondary. */
+    GamepadButton.East = button(1);
+    /** Left face button. Xbox=X, PlayStation=□, Switch=Y. Conventional usage: tertiary action. */
+    GamepadButton.West = button(2);
+    /** Top face button. Xbox=Y, PlayStation=△, Switch=X. Conventional usage: quaternary action. */
+    GamepadButton.North = button(3);
+    GamepadButton.LeftShoulder = button(4);
+    GamepadButton.RightShoulder = button(5);
+    /** Left trigger as a button (analog 0..1 reported through the same channel). */
+    GamepadButton.LeftTrigger = button(6);
+    /** Right trigger as a button. */
+    GamepadButton.RightTrigger = button(7);
+    /** Select / Back / Minus button. */
+    GamepadButton.Select = button(8);
+    /** Start / Options / Plus button. */
+    GamepadButton.Start = button(9);
+    /** Left analog stick click (L3). */
+    GamepadButton.LeftStick = button(10);
+    /** Right analog stick click (R3). */
+    GamepadButton.RightStick = button(11);
+    GamepadButton.DPadUp = button(12);
+    GamepadButton.DPadDown = button(13);
+    GamepadButton.DPadLeft = button(14);
+    GamepadButton.DPadRight = button(15);
+    /** Home / Guide / PS button. */
+    GamepadButton.Guide = button(16);
+    /** Share / Create button (PS4/PS5, Xbox Series). */
+    GamepadButton.Share = button(17);
+    /** Capture / Screenshot button (Switch, Xbox Series). */
+    GamepadButton.Capture = button(18);
+    /** Touchpad click (PlayStation). */
+    GamepadButton.Touchpad = button(19);
+    /** First paddle / extra button (Xbox Elite, Steam Controller, PS5 Edge, Steam Deck L4). */
+    GamepadButton.Paddle1 = button(20);
+    /** Second paddle / extra button (Xbox Elite, Steam Deck R4, PS5 Edge). */
+    GamepadButton.Paddle2 = button(21);
+    /** Third paddle / extra button (Xbox Elite, Steam Deck L5). */
+    GamepadButton.Paddle3 = button(22);
+    /** Fourth paddle / extra button (Xbox Elite, Steam Deck R5). */
+    GamepadButton.Paddle4 = button(23);
+    // Offsets 24..31 reserved for future named buttons / custom mapping use.
+})(GamepadButton || (GamepadButton = {}));
+/* eslint-enable @typescript-eslint/no-namespace, @typescript-eslint/naming-convention */
 
 /**
  * Discriminant tag identifying which device family a {@link GamepadMapping} belongs to.
@@ -13842,26 +14055,53 @@ var GamepadMappingFamily;
     GamepadMappingFamily["JoyConRight"] = "joyConRight";
     GamepadMappingFamily["GameCube"] = "gameCube";
     GamepadMappingFamily["SteamController"] = "steamController";
+    GamepadMappingFamily["SteamDeck"] = "steamDeck";
     GamepadMappingFamily["ArcadeStick"] = "arcadeStick";
 })(GamepadMappingFamily || (GamepadMappingFamily = {}));
 /**
  * Abstract translation layer between the browser's raw {@link https://developer.mozilla.org/en-US/docs/Web/API/Gamepad Gamepad API}
- * indices and ExoJS-canonical {@link GamepadChannel} controls.
+ * indices and ExoJS-canonical channel buffers.
  *
  * Each concrete subclass encodes one device family's button/axis layout as
- * ordered arrays of {@link GamepadControl} objects. The engine selects the
- * appropriate mapping when a gamepad connects and uses it to route raw
- * values to the correct input channels every frame.
+ * ordered arrays of {@link GamepadButton} / {@link GamepadAxis} instances.
+ * The engine selects the appropriate mapping when a gamepad connects and
+ * uses it to route raw values to the correct input channels every frame.
  */
 class GamepadMapping {
-    /** Ordered list of button controls, indexed by the Gamepad API button index. */
+    /** Ordered list of buttons, indexed by the Gamepad API button index. */
     buttons;
-    /** Ordered list of axis controls, indexed by the Gamepad API axis index. */
+    /** Ordered list of axes, indexed by the Gamepad API axis index. */
     axes;
     constructor(buttons, axes) {
         this.buttons = buttons;
         this.axes = axes;
     }
+    /**
+     * Returns `true` when this mapping declares at least one button or axis
+     * control that writes to `channel`. Use to detect device-specific
+     * capabilities at runtime — e.g. before binding an input to a
+     * right-stick channel that may not exist on a single Joy-Con.
+     *
+     * @example
+     * ```ts
+     * if (gamepad.mapping?.hasChannel(GamepadAxis.RightStickX)) {
+     *     pad.onActive(GamepadAxis.RightStickX, (v) => crosshair.x += v * 8);
+     * }
+     * ```
+     */
+    hasChannel(channel) {
+        for (const button of this.buttons) {
+            if (button.channel === channel) {
+                return true;
+            }
+        }
+        for (const axis of this.axes) {
+            if (axis.channel === channel) {
+                return true;
+            }
+        }
+        return false;
+    }
     /**
      * Releases all button and axis control references held by this mapping.
      * Call when the associated gamepad disconnects to allow garbage collection.
@@ -13870,33 +14110,8 @@ class GamepadMapping {
         this.buttons.length = 0;
         this.axes.length = 0;
     }
-    /**
-     * Converts an array of {@link GamepadControlDefinition} tuples into fully
-     * constructed {@link GamepadControl} instances.
-     * Shared factory used by all concrete mapping constructors.
-     */
-    static createControls(definitions) {
-        return definitions.map(([index, channel, options]) => new GamepadControl(index, channel, options));
-    }
 }
 
-const arcadeStickButtonDefinitions = [
-    [0, GamepadChannel.ButtonSouth],
-    [1, GamepadChannel.ButtonEast],
-    [2, GamepadChannel.ButtonWest],
-    [3, GamepadChannel.ButtonNorth],
-    [4, GamepadChannel.LeftShoulder],
-    [5, GamepadChannel.RightShoulder],
-    [6, GamepadChannel.LeftTrigger],
-    [7, GamepadChannel.RightTrigger],
-    [8, GamepadChannel.Select],
-    [9, GamepadChannel.Start],
-    [12, GamepadChannel.DPadUp],
-    [13, GamepadChannel.DPadDown],
-    [14, GamepadChannel.DPadLeft],
-    [15, GamepadChannel.DPadRight],
-    [16, GamepadChannel.Guide],
-];
 /**
  * Mapping for generic arcade-stick controllers.
  *
@@ -13907,65 +14122,190 @@ const arcadeStickButtonDefinitions = [
 class ArcadeStickGamepadMapping extends GamepadMapping {
     family = GamepadMappingFamily.ArcadeStick;
     constructor() {
-        super(GamepadMapping.createControls(arcadeStickButtonDefinitions), []);
+        super([
+            new GamepadButton(0, GamepadButton.South),
+            new GamepadButton(1, GamepadButton.East),
+            new GamepadButton(2, GamepadButton.West),
+            new GamepadButton(3, GamepadButton.North),
+            new GamepadButton(4, GamepadButton.LeftShoulder),
+            new GamepadButton(5, GamepadButton.RightShoulder),
+            new GamepadButton(6, GamepadButton.LeftTrigger),
+            new GamepadButton(7, GamepadButton.RightTrigger),
+            new GamepadButton(8, GamepadButton.Select),
+            new GamepadButton(9, GamepadButton.Start),
+            new GamepadButton(12, GamepadButton.DPadUp),
+            new GamepadButton(13, GamepadButton.DPadDown),
+            new GamepadButton(14, GamepadButton.DPadLeft),
+            new GamepadButton(15, GamepadButton.DPadRight),
+            new GamepadButton(16, GamepadButton.Guide),
+        ], []);
     }
 }
 
-const genericDualAnalogButtonDefinitions = [
-    [0, GamepadChannel.ButtonSouth],
-    [1, GamepadChannel.ButtonEast],
-    [2, GamepadChannel.ButtonWest],
-    [3, GamepadChannel.ButtonNorth],
-    [4, GamepadChannel.LeftShoulder],
-    [5, GamepadChannel.RightShoulder],
-    [6, GamepadChannel.LeftTrigger],
-    [7, GamepadChannel.RightTrigger],
-    [8, GamepadChannel.Select],
-    [9, GamepadChannel.Start],
-    [10, GamepadChannel.LeftStick],
-    [11, GamepadChannel.RightStick],
-    [12, GamepadChannel.DPadUp],
-    [13, GamepadChannel.DPadDown],
-    [14, GamepadChannel.DPadLeft],
-    [15, GamepadChannel.DPadRight],
-    [16, GamepadChannel.Guide],
-    [17, GamepadChannel.Share],
-    [18, GamepadChannel.Capture],
-    [19, GamepadChannel.Touchpad],
-    [20, GamepadChannel.Paddle1],
-];
-const genericDualAnalogAxisDefinitions = [
-    [0, GamepadChannel.LeftStickLeft, { invert: true }],
-    [0, GamepadChannel.LeftStickRight],
-    [1, GamepadChannel.LeftStickUp, { invert: true }],
-    [1, GamepadChannel.LeftStickDown],
-    [2, GamepadChannel.RightStickLeft, { invert: true }],
-    [2, GamepadChannel.RightStickRight],
-    [3, GamepadChannel.RightStickUp, { invert: true }],
-    [3, GamepadChannel.RightStickDown],
-    [4, GamepadChannel.AuxiliaryAxis0Negative, { invert: true }],
-    [4, GamepadChannel.AuxiliaryAxis0Positive],
-    [5, GamepadChannel.AuxiliaryAxis1Negative, { invert: true }],
-    [5, GamepadChannel.AuxiliaryAxis1Positive],
-    [6, GamepadChannel.AuxiliaryAxis2Negative, { invert: true }],
-    [6, GamepadChannel.AuxiliaryAxis2Positive],
-    [7, GamepadChannel.AuxiliaryAxis3Negative, { invert: true }],
-    [7, GamepadChannel.AuxiliaryAxis3Positive],
-];
+/**
+ * Single mappable analog axis on a physical gamepad. Holds the raw browser
+ * `Gamepad.axes[]` index, the canonical channel the value is written to, and
+ * the transform pipeline applied each frame by {@link transformValue}.
+ *
+ * Direction-split axis channels (e.g. `LeftStickLeft`, `LeftStickRight`)
+ * live in the 0..1 range — set `invert: true` on the negative half so it
+ * reads positive when pushed in its direction.
+ *
+ * Aggregate channels (e.g. `LeftStickX`, `LeftStickY`) live in the full
+ * -1..1 range — set `bipolar: true` to preserve sign through the pipeline.
+ *
+ * The static namespace exports (`GamepadAxis.LeftStickLeft`,
+ * `.LeftStickX`, ...) carry the canonical channel offsets used to address
+ * each axis.
+ */
+class GamepadAxis {
+    index;
+    channel;
+    invert;
+    normalize;
+    threshold;
+    bipolar;
+    constructor(index, channel, options = {}) {
+        this.index = index;
+        this.channel = channel;
+        this.invert = options.invert ?? false;
+        this.normalize = options.normalize ?? false;
+        this.threshold = clamp(options.threshold ?? 0.2, 0, 1);
+        this.bipolar = options.bipolar ?? false;
+    }
+    /**
+     * Apply the axis transform pipeline to a raw browser axis value
+     * (typically `Gamepad.axes[i]`, in -1..1).
+     *
+     * Pipeline: clamp to [-1, 1] → optional invert → optional normalize to
+     * [0, 1] → bipolar passthrough OR deadzone (returns 0 when the absolute
+     * value is at or below `threshold`).
+     */
+    transformValue(value) {
+        let result = clamp(value, -1, 1);
+        if (this.invert) {
+            result *= -1;
+        }
+        if (this.normalize) {
+            result = (result + 1) / 2;
+        }
+        if (this.bipolar) {
+            return Math.abs(result) > this.threshold ? result : 0;
+        }
+        return result > this.threshold ? result : 0;
+    }
+}
+const axis = (offset) => (ChannelOffset.Gamepads + offset);
+/* eslint-disable @typescript-eslint/no-namespace, @typescript-eslint/naming-convention */
+/**
+ * Channel-identifier constants. The axis section starts after the 32-slot
+ * button block: 24 named axes (offsets 32..55) plus 8 reserved slots
+ * (offsets 56..63).
+ */
+(function (GamepadAxis) {
+    // Direction-split (0..1, "buttons-style").
+    GamepadAxis.LeftStickLeft = axis(32);
+    GamepadAxis.LeftStickRight = axis(33);
+    GamepadAxis.LeftStickUp = axis(34);
+    GamepadAxis.LeftStickDown = axis(35);
+    GamepadAxis.RightStickLeft = axis(36);
+    GamepadAxis.RightStickRight = axis(37);
+    GamepadAxis.RightStickUp = axis(38);
+    GamepadAxis.RightStickDown = axis(39);
+    // Aggregate (-1..1, "stick-style").
+    /** Signed left-stick X axis (-1..1). Negative = left, positive = right. */
+    GamepadAxis.LeftStickX = axis(40);
+    /** Signed left-stick Y axis (-1..1). Negative = up (screen-up), positive = down. */
+    GamepadAxis.LeftStickY = axis(41);
+    /** Signed right-stick X axis (-1..1). */
+    GamepadAxis.RightStickX = axis(42);
+    /** Signed right-stick Y axis (-1..1). */
+    GamepadAxis.RightStickY = axis(43);
+    // Touchpad XY (PlayStation 4/5, Steam Deck, dual-touchpad Steam-class hardware).
+    /** Primary touchpad X (0..1, left to right). PlayStation, Steam Deck (left pad), Steam Controller. */
+    GamepadAxis.TouchpadX = axis(44);
+    /** Primary touchpad Y (0..1, top to bottom). */
+    GamepadAxis.TouchpadY = axis(45);
+    /** Secondary touchpad X (0..1). Steam Deck (right pad), other dual-touchpad hardware. */
+    GamepadAxis.Touchpad2X = axis(46);
+    /** Secondary touchpad Y (0..1). */
+    GamepadAxis.Touchpad2Y = axis(47);
+    // Auxiliary axes (4 bipolar axes split into 8 non-negative channels).
+    GamepadAxis.AuxiliaryAxis0Negative = axis(48);
+    GamepadAxis.AuxiliaryAxis0Positive = axis(49);
+    GamepadAxis.AuxiliaryAxis1Negative = axis(50);
+    GamepadAxis.AuxiliaryAxis1Positive = axis(51);
+    GamepadAxis.AuxiliaryAxis2Negative = axis(52);
+    GamepadAxis.AuxiliaryAxis2Positive = axis(53);
+    GamepadAxis.AuxiliaryAxis3Negative = axis(54);
+    GamepadAxis.AuxiliaryAxis3Positive = axis(55);
+    // Offsets 56..63 reserved for future named axes / custom mapping use.
+})(GamepadAxis || (GamepadAxis = {}));
+/* eslint-enable @typescript-eslint/no-namespace, @typescript-eslint/naming-convention */
+
 /**
  * Baseline mapping for dual-analog controllers that follow the standard
  * W3C Gamepad API layout (axes 0–3 for both sticks, axes 4–7 auxiliary).
  *
- * Each signed axis is split into two directional channels — one for the
- * negative half and one for the positive half — with the negative channel
- * inverted so all channel values are non-negative during normal use.
+ * Each signed stick axis is exposed three ways for ergonomic binding:
+ *  - Two direction-split, non-negative channels (e.g. `LeftStickLeft` /
+ *    `LeftStickRight`) for "buttons-style" subscriptions.
+ *  - One signed aggregate channel (e.g. `LeftStickX`) for direct -1..1
+ *    consumption — useful for movement or aiming.
+ *
  * Device-specific subclasses (Xbox, PlayStation, Switch Pro, etc.) inherit
  * this layout and override only {@link GamepadMapping.family}.
  */
 class GenericDualAnalogGamepadMapping extends GamepadMapping {
     family = GamepadMappingFamily.GenericDualAnalog;
     constructor() {
-        super(GamepadMapping.createControls(genericDualAnalogButtonDefinitions), GamepadMapping.createControls(genericDualAnalogAxisDefinitions));
+        super([
+            new GamepadButton(0, GamepadButton.South),
+            new GamepadButton(1, GamepadButton.East),
+            new GamepadButton(2, GamepadButton.West),
+            new GamepadButton(3, GamepadButton.North),
+            new GamepadButton(4, GamepadButton.LeftShoulder),
+            new GamepadButton(5, GamepadButton.RightShoulder),
+            new GamepadButton(6, GamepadButton.LeftTrigger),
+            new GamepadButton(7, GamepadButton.RightTrigger),
+            new GamepadButton(8, GamepadButton.Select),
+            new GamepadButton(9, GamepadButton.Start),
+            new GamepadButton(10, GamepadButton.LeftStick),
+            new GamepadButton(11, GamepadButton.RightStick),
+            new GamepadButton(12, GamepadButton.DPadUp),
+            new GamepadButton(13, GamepadButton.DPadDown),
+            new GamepadButton(14, GamepadButton.DPadLeft),
+            new GamepadButton(15, GamepadButton.DPadRight),
+            new GamepadButton(16, GamepadButton.Guide),
+            new GamepadButton(17, GamepadButton.Share),
+            new GamepadButton(18, GamepadButton.Capture),
+            new GamepadButton(19, GamepadButton.Touchpad),
+            new GamepadButton(20, GamepadButton.Paddle1),
+        ], [
+            // Direction-split (0..1).
+            new GamepadAxis(0, GamepadAxis.LeftStickLeft, { invert: true }),
+            new GamepadAxis(0, GamepadAxis.LeftStickRight),
+            new GamepadAxis(1, GamepadAxis.LeftStickUp, { invert: true }),
+            new GamepadAxis(1, GamepadAxis.LeftStickDown),
+            new GamepadAxis(2, GamepadAxis.RightStickLeft, { invert: true }),
+            new GamepadAxis(2, GamepadAxis.RightStickRight),
+            new GamepadAxis(3, GamepadAxis.RightStickUp, { invert: true }),
+            new GamepadAxis(3, GamepadAxis.RightStickDown),
+            // Aggregate signed channels (-1..1).
+            new GamepadAxis(0, GamepadAxis.LeftStickX, { bipolar: true }),
+            new GamepadAxis(1, GamepadAxis.LeftStickY, { bipolar: true }),
+            new GamepadAxis(2, GamepadAxis.RightStickX, { bipolar: true }),
+            new GamepadAxis(3, GamepadAxis.RightStickY, { bipolar: true }),
+            // Auxiliary axes (4 bipolar physical axes split into 8 half-channels).
+            new GamepadAxis(4, GamepadAxis.AuxiliaryAxis0Negative, { invert: true }),
+            new GamepadAxis(4, GamepadAxis.AuxiliaryAxis0Positive),
+            new GamepadAxis(5, GamepadAxis.AuxiliaryAxis1Negative, { invert: true }),
+            new GamepadAxis(5, GamepadAxis.AuxiliaryAxis1Positive),
+            new GamepadAxis(6, GamepadAxis.AuxiliaryAxis2Negative, { invert: true }),
+            new GamepadAxis(6, GamepadAxis.AuxiliaryAxis2Positive),
+            new GamepadAxis(7, GamepadAxis.AuxiliaryAxis3Negative, { invert: true }),
+            new GamepadAxis(7, GamepadAxis.AuxiliaryAxis3Positive),
+        ]);
     }
 }
 
@@ -13983,29 +14323,83 @@ class GameCubeGamepadMapping extends GenericDualAnalogGamepadMapping {
 }
 
 /**
- * Mapping for the Nintendo Switch Joy-Con (L) held horizontally or used as
- * a standalone controller.
- *
- * Inherits the {@link GenericDualAnalogGamepadMapping} layout. Because the
- * Joy-Con Left has only one physical stick, right-stick channels will never
- * receive input when this mapping is active. The SL/SR shoulder buttons are
- * surfaced through the standard LeftShoulder/RightShoulder channels.
+ * Mapping for the Nintendo Joy-Con (L) held horizontally as a solo controller.
+ *
+ * Declares only channels that physically exist on the device — one stick
+ * (mapped to {@link GamepadAxis.LeftStickX} / `LeftStickY` and the
+ * direction-split equivalents), four face buttons, the SL/SR inner shoulders
+ * (routed through the standard shoulder channels), Minus, the Capture
+ * button, and the stick-click.
+ *
+ * Right-stick channels, triggers, Plus/Home, Touchpad, paddles, and
+ * auxiliary axes are intentionally absent. Use
+ * {@link GamepadMapping.hasChannel} to detect availability before binding
+ * inputs that may not exist on every device family.
  */
-class JoyConLeftGamepadMapping extends GenericDualAnalogGamepadMapping {
+class JoyConLeftGamepadMapping extends GamepadMapping {
     family = GamepadMappingFamily.JoyConLeft;
+    constructor() {
+        super([
+            new GamepadButton(0, GamepadButton.South),
+            new GamepadButton(1, GamepadButton.East),
+            new GamepadButton(2, GamepadButton.West),
+            new GamepadButton(3, GamepadButton.North),
+            // Inner SL/SR shoulders — routed through the standard shoulder channels.
+            new GamepadButton(4, GamepadButton.LeftShoulder),
+            new GamepadButton(5, GamepadButton.RightShoulder),
+            new GamepadButton(8, GamepadButton.Select), // Minus
+            new GamepadButton(10, GamepadButton.LeftStick), // stick click
+            new GamepadButton(16, GamepadButton.Capture),
+        ], [
+            // Single physical stick — surfaced through the LeftStick channels so
+            // gamepad-agnostic code that binds to "the stick" works regardless of
+            // which Joy-Con is held.
+            new GamepadAxis(0, GamepadAxis.LeftStickLeft, { invert: true }),
+            new GamepadAxis(0, GamepadAxis.LeftStickRight),
+            new GamepadAxis(1, GamepadAxis.LeftStickUp, { invert: true }),
+            new GamepadAxis(1, GamepadAxis.LeftStickDown),
+            new GamepadAxis(0, GamepadAxis.LeftStickX, { bipolar: true }),
+            new GamepadAxis(1, GamepadAxis.LeftStickY, { bipolar: true }),
+        ]);
+    }
 }
 
 /**
- * Mapping for the Nintendo Switch Joy-Con (R) held horizontally or used as
- * a standalone controller.
- *
- * Inherits the {@link GenericDualAnalogGamepadMapping} layout. Because the
- * Joy-Con Right has only one physical stick, left-stick channels will never
- * receive input when this mapping is active. The SL/SR shoulder buttons are
- * surfaced through the standard LeftShoulder/RightShoulder channels.
+ * Mapping for the Nintendo Joy-Con (R) held horizontally as a solo controller.
+ *
+ * Declares only channels that physically exist on the device — one stick
+ * (mapped to the LeftStick channels to match the W3C standard layout for the
+ * lone reported stick regardless of which Joy-Con reports it), four face
+ * buttons, the SL/SR inner shoulders (routed through the standard shoulder
+ * channels), Plus, the Home button, and the stick-click.
+ *
+ * Right-stick channels, triggers, Minus/Capture, Touchpad, paddles, and
+ * auxiliary axes are intentionally absent. Use
+ * {@link GamepadMapping.hasChannel} to detect availability before binding
+ * inputs that may not exist on every device family.
  */
-class JoyConRightGamepadMapping extends GenericDualAnalogGamepadMapping {
+class JoyConRightGamepadMapping extends GamepadMapping {
     family = GamepadMappingFamily.JoyConRight;
+    constructor() {
+        super([
+            new GamepadButton(0, GamepadButton.South),
+            new GamepadButton(1, GamepadButton.East),
+            new GamepadButton(2, GamepadButton.West),
+            new GamepadButton(3, GamepadButton.North),
+            new GamepadButton(4, GamepadButton.LeftShoulder),
+            new GamepadButton(5, GamepadButton.RightShoulder),
+            new GamepadButton(9, GamepadButton.Start), // Plus
+            new GamepadButton(10, GamepadButton.LeftStick), // stick click
+            new GamepadButton(16, GamepadButton.Guide), // Home
+        ], [
+            new GamepadAxis(0, GamepadAxis.LeftStickLeft, { invert: true }),
+            new GamepadAxis(0, GamepadAxis.LeftStickRight),
+            new GamepadAxis(1, GamepadAxis.LeftStickUp, { invert: true }),
+            new GamepadAxis(1, GamepadAxis.LeftStickDown),
+            new GamepadAxis(0, GamepadAxis.LeftStickX, { bipolar: true }),
+            new GamepadAxis(1, GamepadAxis.LeftStickY, { bipolar: true }),
+        ]);
+    }
 }
 
 /**
@@ -14032,6 +14426,76 @@ class SteamControllerGamepadMapping extends GenericDualAnalogGamepadMapping {
     family = GamepadMappingFamily.SteamController;
 }
 
+/**
+ * Mapping for the Valve Steam Deck (and the new Valve Controller via vendor
+ * fallback) when its raw HID gamepad is exposed directly to the browser —
+ * i.e. when Steam Input is *not* intercepting the device. With Steam Input
+ * intercepting, the device appears as `28de:11ff` "Steam Virtual Gamepad"
+ * with a standard W3C layout instead, and is routed to
+ * {@link GenericDualAnalogGamepadMapping}.
+ *
+ * The raw layout is non-standard: face buttons live at indices 3-6 (not the
+ * W3C-standard 0-3), the D-pad lives at indices 16-19, paddles at 20-23, and
+ * triggers report as analog axes 8/9 rather than buttons 6/7. Indices are
+ * derived from the Linux SDL_GameControllerDB entry for `Valve Steam Deck`.
+ */
+class SteamDeckGamepadMapping extends GamepadMapping {
+    family = GamepadMappingFamily.SteamDeck;
+    constructor() {
+        super([
+            // Quick Access (Steam Deck "..." button) → mapped to Capture as
+            // the closest semantic match in the canonical channel set.
+            new GamepadButton(2, GamepadButton.Capture),
+            // Face cluster — non-standard offsets.
+            new GamepadButton(3, GamepadButton.South),
+            new GamepadButton(4, GamepadButton.East),
+            new GamepadButton(5, GamepadButton.West),
+            new GamepadButton(6, GamepadButton.North),
+            new GamepadButton(7, GamepadButton.LeftShoulder),
+            new GamepadButton(8, GamepadButton.RightShoulder),
+            // View / Menu / Steam buttons.
+            new GamepadButton(11, GamepadButton.Select),
+            new GamepadButton(12, GamepadButton.Start),
+            new GamepadButton(13, GamepadButton.Guide),
+            // Stick clicks.
+            new GamepadButton(14, GamepadButton.LeftStick),
+            new GamepadButton(15, GamepadButton.RightStick),
+            // D-pad.
+            new GamepadButton(16, GamepadButton.DPadUp),
+            new GamepadButton(17, GamepadButton.DPadDown),
+            new GamepadButton(18, GamepadButton.DPadLeft),
+            new GamepadButton(19, GamepadButton.DPadRight),
+            // Back paddles. SDL labels them paddle1=R4, paddle2=L4,
+            // paddle3=R5, paddle4=L5; we expose them in canonical
+            // L4/R4/L5/R5 order via Paddle1..Paddle4.
+            new GamepadButton(20, GamepadButton.Paddle2),
+            new GamepadButton(21, GamepadButton.Paddle1),
+            new GamepadButton(22, GamepadButton.Paddle4),
+            new GamepadButton(23, GamepadButton.Paddle3),
+        ], [
+            // Sticks — direction-split (0..1).
+            new GamepadAxis(0, GamepadAxis.LeftStickLeft, { invert: true }),
+            new GamepadAxis(0, GamepadAxis.LeftStickRight),
+            new GamepadAxis(1, GamepadAxis.LeftStickUp, { invert: true }),
+            new GamepadAxis(1, GamepadAxis.LeftStickDown),
+            new GamepadAxis(2, GamepadAxis.RightStickLeft, { invert: true }),
+            new GamepadAxis(2, GamepadAxis.RightStickRight),
+            new GamepadAxis(3, GamepadAxis.RightStickUp, { invert: true }),
+            new GamepadAxis(3, GamepadAxis.RightStickDown),
+            // Sticks — aggregate signed (-1..1).
+            new GamepadAxis(0, GamepadAxis.LeftStickX, { bipolar: true }),
+            new GamepadAxis(1, GamepadAxis.LeftStickY, { bipolar: true }),
+            new GamepadAxis(2, GamepadAxis.RightStickX, { bipolar: true }),
+            new GamepadAxis(3, GamepadAxis.RightStickY, { bipolar: true }),
+            // Triggers as analog axes (Steam Deck reports them as a8/a9,
+            // not buttons). Browsers expose -1..+1; normalize to 0..1
+            // for the canonical trigger channels.
+            new GamepadAxis(8, GamepadAxis.AuxiliaryAxis0Positive, { normalize: true }),
+            new GamepadAxis(9, GamepadAxis.AuxiliaryAxis1Positive, { normalize: true }),
+        ]);
+    }
+}
+
 /**
  * Mapping for the Nintendo Switch Pro Controller connected via USB or
  * Bluetooth.
@@ -14222,6 +14686,8 @@ const exactDeviceDefinitions = [
     createStaticGamepadDefinition('Switch 2 Pro Controller', () => new SwitchProGamepadMapping(), '057e:2069'),
     createStaticGamepadDefinition('Switch 2 GameCube Controller', () => new GameCubeGamepadMapping(), '057e:2073'),
     createStaticGamepadDefinition('Steam Controller', () => new SteamControllerGamepadMapping(), ['28de:1102', '28de:1142']),
+    createStaticGamepadDefinition('Steam Virtual Gamepad', () => new GenericDualAnalogGamepadMapping(), '28de:11ff'),
+    createStaticGamepadDefinition('Steam Deck', () => new SteamDeckGamepadMapping(), '28de:1205'),
     createStaticGamepadDefinition('F310 Gamepad', () => new GenericDualAnalogGamepadMapping(), '046d:c216'),
     createStaticGamepadDefinition('F710 Gamepad', () => new GenericDualAnalogGamepadMapping(), ['046d:c219', '046d:c21f']),
     createStaticGamepadDefinition('8BitDo P30 Controller', () => new GenericDualAnalogGamepadMapping(), ['2dc8:5107', '2dc8:5108']),
@@ -14244,6 +14710,7 @@ const exactDeviceDefinitions = [
 const vendorFallbackDefinitions = [
     createStaticGamepadDefinition('Microsoft Controller', () => new XboxGamepadMapping(), '045e'),
     createStaticGamepadDefinition('Sony Controller', () => new PlayStationGamepadMapping(), '054c'),
+    createStaticGamepadDefinition('Valve Controller', () => new SteamDeckGamepadMapping(), '28de'),
 ];
 const genericFallbackDefinition = createStaticGamepadDefinition('Generic Gamepad', () => new GenericDualAnalogGamepadMapping());
 /**
@@ -14259,6 +14726,7 @@ const builtInGamepadDefinitions = [
     genericFallbackDefinition,
 ];
 
+const gamepadSlots = 4;
 var InputManagerFlag;
 (function (InputManagerFlag) {
     InputManagerFlag[InputManagerFlag["None"] = 0] = "None";
@@ -14275,10 +14743,11 @@ var InputManagerFlag;
  * rotate / long-press).
  *
  * All raw inputs are written into a shared `Float32Array` channel buffer.
- * Bind {@link Input} instances to channel indices to react to specific
- * keys, gamepad controls, or pointer slots without rolling your own event
- * routing. Direct subscribers can use the per-event Signals
- * (`onKeyDown`, `onPointerDown`, `onGamepadConnected`, `onPinch`, …).
+ * Bind input listeners via the {@link onTrigger} / {@link onActive} /
+ * {@link onStart} / {@link onStop} factory methods (or via
+ * {@link Gamepad.onTrigger}-style methods on individual pads), or
+ * subscribe to the signal-style notifications
+ * (`onKeyDown`, `onPointerDown`, `onGamepadConnected`, `onAnyGamepadButtonDown`, …).
  *
  * Driven each frame by {@link Application.update}; constructed
  * automatically — you do not instantiate this class yourself.
@@ -14286,18 +14755,19 @@ var InputManagerFlag;
 class InputManager {
     canvas;
     channels = new Float32Array(ChannelSize.Container);
-    inputs = new Set();
     pointers = {};
-    gamepadsValue = [];
-    gamepadsByIndex = new Map();
-    gamepadSlotsActive = new Uint8Array(ChannelSize.Category / ChannelSize.Gamepad);
+    _gamepads;
+    gamepadsByBrowserIndex = new Map();
+    bindings = new Set();
+    bindingDetacher = { detach: (binding) => { this.bindings.delete(binding); } };
     wheelOffset = new Vector();
     flags = new Flags();
     channelsPressed = [];
     channelsReleased = [];
     gamepadDefinitions;
+    slotStrategy;
     // Slot allocation for unified pointer tracking (mouse / touch / pen).
-    pointerSlots = new Map(); // pointerId → slotIndex
+    pointerSlots = new Map();
     freeSlots = Array.from({ length: maxPointers }, (_, i) => i);
     gestureRecognizer;
     canvasFocusedValue;
@@ -14326,9 +14796,22 @@ class InputManager {
     onMouseWheel = new Signal();
     onKeyDown = new Signal();
     onKeyUp = new Signal();
+    /** Fires when a physical pad connects to any slot. */
     onGamepadConnected = new Signal();
+    /** Fires when a physical pad disconnects from any slot. */
     onGamepadDisconnected = new Signal();
-    onGamepadUpdated = new Signal();
+    /**
+     * Fires when a `'compact'`-strategy disconnect shifts a higher-numbered
+     * slot's pad into a lower one. Dispatched once per moved pad with the
+     * destination slot and the slot index it came from.
+     */
+    onAnyGamepadReassigned = new Signal();
+    /** Fires whenever any pad reports a button press transition. */
+    onAnyGamepadButtonDown = new Signal();
+    /** Fires whenever any pad reports a button release transition. */
+    onAnyGamepadButtonUp = new Signal();
+    /** Fires whenever any pad reports an axis value change. */
+    onAnyGamepadAxisChange = new Signal();
     /** Fires on every two-touch-pointer move where the distance between them changed. `scale` > 1 = spreading, < 1 = pinching. */
     onPinch = new Signal();
     /** Fires on every two-touch-pointer move where the angle between them changed. `angleDelta` is in radians. */
@@ -14336,16 +14819,25 @@ class InputManager {
     /** Fires when a pointer has been held without significant movement for ≥ 500 ms. */
     onLongPress = new Signal();
     constructor(app) {
-        const { gamepadDefinitions = [], pointerDistanceThreshold } = app.options;
+        const { gamepadDefinitions = [], pointerDistanceThreshold, gamepadSlotStrategy = 'sticky', } = app.options;
         this.canvas = app.canvas;
         this.canvasFocusedValue = document.activeElement === this.canvas;
         this.pointerDistanceThreshold = pointerDistanceThreshold;
         this.gamepadDefinitions = [...gamepadDefinitions, ...builtInGamepadDefinitions];
+        this.slotStrategy = gamepadSlotStrategy;
         // Disable the browser's default pan/zoom/double-tap-zoom on touch devices so
         // pointer events reach the canvas without being swallowed by the browser's
         // native touch gestures.
         this.canvas.style.touchAction = 'none';
         this.gestureRecognizer = new GestureRecognizer(pointerDistanceThreshold, this.onPinch, this.onRotate, this.onLongPress);
+        const slot0 = new Gamepad(0, this.channels);
+        const slot1 = new Gamepad(1, this.channels);
+        const slot2 = new Gamepad(2, this.channels);
+        const slot3 = new Gamepad(3, this.channels);
+        this._gamepads = [slot0, slot1, slot2, slot3];
+        for (const pad of this._gamepads) {
+            this.wireGamepadEvents(pad);
+        }
         this.addEventListeners();
     }
     /**
@@ -14359,7 +14851,6 @@ class InputManager {
                 return { x: pointer.x, y: pointer.y };
             }
         }
-        // Fall back to first non-cancelled pointer.
         for (const pointer of Object.values(this.pointers)) {
             if (pointer.currentState !== PointerState.Cancelled) {
                 return { x: pointer.x, y: pointer.y };
@@ -14374,58 +14865,103 @@ class InputManager {
     get canvasFocused() {
         return this.canvasFocusedValue;
     }
+    /**
+     * Always-4 array of {@link Gamepad} slot mailboxes. Each entry exists for
+     * the application's full lifetime; check `pad.connected` for hardware
+     * presence. Listeners attached to a slot survive disconnect/reconnect.
+     */
     get gamepads() {
-        return this.gamepadsValue;
+        return this._gamepads;
     }
-    getGamepad(index) {
-        return this.gamepadsByIndex.get(index) ?? null;
+    /** The slot strategy active for this `InputManager`. */
+    get gamepadSlotStrategy() {
+        return this.slotStrategy;
     }
     /**
-     * Register one or more {@link Input} bindings so they participate in the
-     * per-frame channel-buffer reads. Idempotent for already-registered
-     * inputs; chainable.
+     * Direct accessor for a single gamepad slot. Equivalent to
+     * `app.input.gamepads[slot]` but reads more clearly at call sites.
      */
-    add(inputs) {
-        if (Array.isArray(inputs)) {
-            inputs.forEach((input) => this.add(input));
-            return this;
+    getGamepad(slot) {
+        return this._gamepads[slot];
+    }
+    /** Subset of {@link gamepads} containing only currently connected pads, in slot order. */
+    get connectedGamepads() {
+        const result = [];
+        for (const pad of this._gamepads) {
+            if (pad.connected) {
+                result.push(pad);
+            }
         }
-        this.inputs.add(inputs);
-        return this;
+        return result;
+    }
+    /** Number of slots currently occupied by a physical gamepad. */
+    get connectedGamepadCount() {
+        let count = 0;
+        for (const pad of this._gamepads) {
+            if (pad.connected) {
+                count++;
+            }
+        }
+        return count;
+    }
+    /** First connected gamepad in slot order, or `null` when no pads are attached. */
+    get firstConnectedGamepad() {
+        for (const pad of this._gamepads) {
+            if (pad.connected) {
+                return pad;
+            }
+        }
+        return null;
+    }
+    /** `true` when at least one slot is occupied by a physical gamepad. */
+    get hasGamepad() {
+        for (const pad of this._gamepads) {
+            if (pad.connected) {
+                return true;
+            }
+        }
+        return false;
+    }
+    /**
+     * Register a callback fired once when any of `channels` becomes active.
+     * Manual lifecycle — call `.unbind()` on the returned binding to detach.
+     */
+    onStart(channel, callback, options) {
+        const binding = this.createBinding(channel, options);
+        binding.onStart.add(callback);
+        return binding;
+    }
+    /** Register a callback fired every frame while any of `channels` is active. */
+    onActive(channel, callback, options) {
+        const binding = this.createBinding(channel, options);
+        binding.onActive.add(callback);
+        return binding;
     }
-    /** Unregister one or more {@link Input} bindings. */
-    remove(inputs) {
-        if (Array.isArray(inputs)) {
-            inputs.forEach((input) => this.remove(input));
-            return this;
-        }
-        this.inputs.delete(inputs);
-        return this;
+    /** Register a callback fired once when all of `channels` become inactive. */
+    onStop(channel, callback, options) {
+        const binding = this.createBinding(channel, options);
+        binding.onStop.add(callback);
+        return binding;
     }
     /**
-     * Drop every registered {@link Input}. Pass `destroyInputs = true` to
-     * also call `.destroy()` on each one (releases its Signals); default
-     * `false` leaves them intact for re-registration.
+     * Register a callback fired when the input is released within
+     * {@link InputBindingOptions.threshold} ms of activation (a "tap").
      */
-    clear(destroyInputs = false) {
-        if (destroyInputs) {
-            for (const input of this.inputs) {
-                input.destroy();
-            }
-        }
-        this.inputs.clear();
-        return this;
+    onTrigger(channel, callback, options) {
+        const binding = this.createBinding(channel, options);
+        binding.onTrigger.add(callback);
+        return binding;
     }
     /**
      * Per-frame entry point invoked by {@link Application.update}. Polls
      * the gamepad API, drains queued keyboard/pointer/wheel deltas into
      * the channel buffer, fires the corresponding Signals, then evaluates
-     * each registered {@link Input}.
+     * each registered binding.
      */
     update() {
         this.updateGamepads();
-        for (const input of this.inputs) {
-            input.update(this.channels);
+        for (const binding of this.bindings) {
+            binding.update(this.channels);
         }
         if (this.flags.value !== InputManagerFlag.None) {
             this.updateEvents();
@@ -14438,12 +14974,14 @@ class InputManager {
         for (const pointer of Object.values(this.pointers)) {
             pointer.destroy();
         }
-        for (const gamepad of this.gamepadsValue) {
-            gamepad.destroy();
+        for (const pad of this._gamepads) {
+            pad.destroy();
         }
-        this.inputs.clear();
-        this.gamepadsByIndex.clear();
-        this.gamepadsValue.length = 0;
+        for (const binding of Array.from(this.bindings)) {
+            binding.unbind();
+        }
+        this.bindings.clear();
+        this.gamepadsByBrowserIndex.clear();
         this.channelsPressed.length = 0;
         this.channelsReleased.length = 0;
         this.pointerSlots.clear();
@@ -14463,18 +15001,40 @@ class InputManager {
         this.onKeyUp.destroy();
         this.onGamepadConnected.destroy();
         this.onGamepadDisconnected.destroy();
-        this.onGamepadUpdated.destroy();
+        this.onAnyGamepadReassigned.destroy();
+        this.onAnyGamepadButtonDown.destroy();
+        this.onAnyGamepadButtonUp.destroy();
+        this.onAnyGamepadAxisChange.destroy();
         this.onPinch.destroy();
         this.onRotate.destroy();
         this.onLongPress.destroy();
         this.onCanvasFocusChange.destroy();
     }
+    createBinding(channel, options = {}) {
+        const list = Array.isArray(channel) ? channel : [channel];
+        const slot = options.gamepadSlot ?? 0;
+        const resolved = list.map((c) => this.resolveExternalChannel(c, slot));
+        const binding = new InputBinding(resolved, options, this.bindingDetacher);
+        this.bindings.add(binding);
+        return binding;
+    }
+    resolveExternalChannel(channel, slot) {
+        if (channel >= ChannelOffset.Gamepads && channel < ChannelOffset.Gamepads + ChannelSize.Category) {
+            return ChannelOffset.Gamepads + (slot * ChannelSize.Gamepad) + (channel ^ ChannelOffset.Gamepads);
+        }
+        return channel;
+    }
+    wireGamepadEvents(pad) {
+        pad.onButtonDown.add((button, value) => { this.onAnyGamepadButtonDown.dispatch(pad, button, value); });
+        pad.onButtonUp.add((button, value) => { this.onAnyGamepadButtonUp.dispatch(pad, button, value); });
+        pad.onAxisChange.add((axis, value) => { this.onAnyGamepadAxisChange.dispatch(pad, axis, value); });
+    }
     _assignSlot(pointerId) {
         if (this.pointerSlots.has(pointerId)) {
             return this.pointerSlots.get(pointerId);
         }
         if (this.freeSlots.length === 0) {
-            return null; // All 16 slots occupied — silently drop.
+            return null;
         }
         const slot = this.freeSlots.shift();
         this.pointerSlots.set(pointerId, slot);
@@ -14484,14 +15044,10 @@ class InputManager {
         const slot = this.pointerSlots.get(pointerId);
         if (slot !== undefined) {
             this.pointerSlots.delete(pointerId);
-            // Push to the front so slot 0 is recovered first, keeping allocation predictable.
             this.freeSlots.unshift(slot);
         }
     }
     handleKeyDown(event) {
-        // Game-engine convention: keys only register while the canvas
-        // owns focus. Otherwise typing into adjacent <input> fields would
-        // also drive game state, which is never what users want.
         if (!this.canvasFocusedValue) {
             return;
         }
@@ -14499,9 +15055,6 @@ class InputManager {
         this.channels[channel] = 1;
         this.channelsPressed.push(channel);
         this.flags.push(InputManagerFlag.KeyDown);
-        // Consume the event: stop default browser actions (page scroll on
-        // arrow/space, find-as-you-type on /, etc.) and stop propagation
-        // so other listeners on the page don't double-handle.
         stopEvent(event);
     }
     handleKeyUp(event) {
@@ -14517,7 +15070,7 @@ class InputManager {
     handlePointerOver(event) {
         const slot = this._assignSlot(event.pointerId);
         if (slot === null) {
-            return; // 17th+ simultaneous pointer — silently drop.
+            return;
         }
         this.pointers[event.pointerId] = new Pointer(event, this.canvas, this.channels, slot);
         this.flags.push(InputManagerFlag.PointerUpdate);
@@ -14542,10 +15095,6 @@ class InputManager {
         pointer.handlePress(event);
         this.gestureRecognizer.onPointerDown(pointer);
         this.flags.push(InputManagerFlag.PointerUpdate);
-        // preventDefault stops native drag / text-selection;
-        // stopImmediatePropagation prevents bubbling to host-page click
-        // handlers so an embedded canvas doesn't accidentally trigger UI
-        // outside its bounds.
         stopEvent(event);
     }
     handlePointerMove(event) {
@@ -14605,13 +15154,6 @@ class InputManager {
             this.onCanvasFocusChange.dispatch(false);
         }
     }
-    /**
-     * Force every currently-held keyboard channel back to zero and emit
-     * onKeyUp for each. Called on canvas/window blur so keys held when
-     * focus leaves don't stay stuck "down" forever — without this, a user
-     * who alt-tabs while pressing W would have W register as held until
-     * they manually release while focus is back.
-     */
     releaseAllKeyboardChannels() {
         for (let offset = 0; offset < ChannelSize.Category; offset++) {
             const channel = ChannelOffset.Keyboard + offset;
@@ -14660,49 +15202,98 @@ class InputManager {
         this.canvas.removeEventListener('selectstart', stopEvent, activeListenerOption);
     }
     updateGamepads() {
-        const activeGamepads = window.navigator.getGamepads();
-        this.gamepadSlotsActive.fill(0);
-        for (const activeGamepad of activeGamepads) {
-            if (!activeGamepad) {
+        const browserGamepads = window.navigator.getGamepads();
+        const seenBrowserIndices = new Set();
+        for (const browserGamepad of browserGamepads) {
+            if (!browserGamepad) {
                 continue;
             }
-            const activeIndex = activeGamepad.index;
-            if (activeIndex < 0 || activeIndex >= this.gamepadSlotsActive.length) {
+            const browserIndex = browserGamepad.index;
+            if (browserIndex < 0) {
                 continue;
             }
-            this.gamepadSlotsActive[activeIndex] = 1;
-            let gamepad = this.gamepadsByIndex.get(activeIndex);
-            if (!gamepad) {
-                const definition = resolveGamepadDefinition(activeGamepad, this.gamepadDefinitions);
-                gamepad = new Gamepad(activeGamepad, this.channels, definition);
-                this.gamepadsByIndex.set(activeIndex, gamepad);
-                this.insertGamepadByIndex(gamepad);
-                this.onGamepadConnected.dispatch(gamepad, this.gamepadsValue);
-            }
-            else {
-                gamepad.connect(activeGamepad);
+            seenBrowserIndices.add(browserIndex);
+            const existing = this.gamepadsByBrowserIndex.get(browserIndex);
+            if (existing === undefined) {
+                const pad = this.assignSlotForNewPad(browserGamepad);
+                if (pad === null) {
+                    continue;
+                }
+                this.gamepadsByBrowserIndex.set(browserIndex, pad);
+                this.onGamepadConnected.dispatch(pad);
             }
-            gamepad.update();
-            this.onGamepadUpdated.dispatch(gamepad, this.gamepadsValue);
         }
-        for (let index = this.gamepadsValue.length - 1; index >= 0; index -= 1) {
-            const gamepad = this.gamepadsValue[index];
-            if (this.gamepadSlotsActive[gamepad.index] === 0) {
-                gamepad.disconnect();
-                this.gamepadsValue.splice(index, 1);
-                this.gamepadsByIndex.delete(gamepad.index);
-                this.onGamepadDisconnected.dispatch(gamepad, this.gamepadsValue);
-                gamepad.destroy();
+        for (const [browserIndex, pad] of Array.from(this.gamepadsByBrowserIndex.entries())) {
+            if (!seenBrowserIndices.has(browserIndex)) {
+                this.gamepadsByBrowserIndex.delete(browserIndex);
+                this.handleGamepadDisconnect(pad);
             }
         }
+        for (const pad of this._gamepads) {
+            pad.update();
+        }
         return this;
     }
-    insertGamepadByIndex(gamepad) {
-        let insertIndex = 0;
-        while (insertIndex < this.gamepadsValue.length && this.gamepadsValue[insertIndex].index < gamepad.index) {
-            insertIndex += 1;
+    assignSlotForNewPad(browserGamepad) {
+        const definition = resolveGamepadDefinition(browserGamepad, this.gamepadDefinitions);
+        for (const pad of this._gamepads) {
+            if (!pad.connected) {
+                pad._bind(browserGamepad, definition);
+                return pad;
+            }
+        }
+        return null;
+    }
+    handleGamepadDisconnect(pad) {
+        if (this.slotStrategy !== 'compact') {
+            // Sticky: pad's slot becomes empty in place; fire onDisconnect
+            // on that slot directly.
+            pad._unbind();
+            this.onGamepadDisconnected.dispatch(pad);
+            return;
+        }
+        // Compact: in semantic terms the user lost a player, and the trailing
+        // (highest-numbered) occupied slot is the one that becomes empty.
+        // 1. Snapshot the highest occupied slot before any state change.
+        // 2. Silently vacate the disconnecting pad (no onDisconnect yet).
+        // 3. Shift higher-numbered occupied slots down to fill any gaps,
+        //    firing onPadReassigned for each slot that received a new pad.
+        // 4. Fire onDisconnect on the slot that ended up empty (the one
+        //    snapshotted in step 1).
+        let lastOccupiedSlot = -1;
+        for (let i = gamepadSlots - 1; i >= 0; i--) {
+            if (this._gamepads[i].connected) {
+                lastOccupiedSlot = i;
+                break;
+            }
+        }
+        pad._silentUnbind();
+        for (let target = 0; target < gamepadSlots; target++) {
+            if (this._gamepads[target].connected) {
+                continue;
+            }
+            for (let source = target + 1; source < gamepadSlots; source++) {
+                const sourcePad = this._gamepads[source];
+                if (!sourcePad.connected) {
+                    continue;
+                }
+                const browserIndex = sourcePad.browserGamepad?.index;
+                const targetPad = this._gamepads[target];
+                const sourceSlot = sourcePad.slot;
+                targetPad._rebindFrom(sourcePad);
+                if (browserIndex !== undefined) {
+                    this.gamepadsByBrowserIndex.set(browserIndex, targetPad);
+                }
+                targetPad.onPadReassigned.dispatch(sourceSlot);
+                this.onAnyGamepadReassigned.dispatch(targetPad, sourceSlot);
+                break;
+            }
+        }
+        if (lastOccupiedSlot >= 0) {
+            const emptiedSlot = this._gamepads[lastOccupiedSlot];
+            emptiedSlot._dispatchDisconnect();
+            this.onGamepadDisconnected.dispatch(emptiedSlot);
         }
-        this.gamepadsValue.splice(insertIndex, 0, gamepad);
     }
     updateEvents() {
         if (this.flags.pop(InputManagerFlag.KeyDown)) {
@@ -15324,12 +15915,12 @@ class InteractionManager {
         this._onPointerTapHandler = this._handlePointerTap.bind(this);
         this._onPointerCancelHandler = this._handlePointerCancel.bind(this);
         this._onPointerLeaveHandler = this._handlePointerLeave.bind(this);
-        app.inputManager.onPointerDown.add(this._onPointerDownHandler);
-        app.inputManager.onPointerMove.add(this._onPointerMoveHandler);
-        app.inputManager.onPointerUp.add(this._onPointerUpHandler);
-        app.inputManager.onPointerTap.add(this._onPointerTapHandler);
-        app.inputManager.onPointerCancel.add(this._onPointerCancelHandler);
-        app.inputManager.onPointerLeave.add(this._onPointerLeaveHandler);
+        app.input.onPointerDown.add(this._onPointerDownHandler);
+        app.input.onPointerMove.add(this._onPointerMoveHandler);
+        app.input.onPointerUp.add(this._onPointerUpHandler);
+        app.input.onPointerTap.add(this._onPointerTapHandler);
+        app.input.onPointerCancel.add(this._onPointerCancelHandler);
+        app.input.onPointerLeave.add(this._onPointerLeaveHandler);
     }
     /**
      * Returns the RenderNode currently hovered by the given pointer, or null.
@@ -15373,12 +15964,12 @@ class InteractionManager {
         return this._quadtree;
     }
     destroy() {
-        this._app.inputManager.onPointerDown.remove(this._onPointerDownHandler);
-        this._app.inputManager.onPointerMove.remove(this._onPointerMoveHandler);
-        this._app.inputManager.onPointerUp.remove(this._onPointerUpHandler);
-        this._app.inputManager.onPointerTap.remove(this._onPointerTapHandler);
-        this._app.inputManager.onPointerCancel.remove(this._onPointerCancelHandler);
-        this._app.inputManager.onPointerLeave.remove(this._onPointerLeaveHandler);
+        this._app.input.onPointerDown.remove(this._onPointerDownHandler);
+        this._app.input.onPointerMove.remove(this._onPointerMoveHandler);
+        this._app.input.onPointerUp.remove(this._onPointerUpHandler);
+        this._app.input.onPointerTap.remove(this._onPointerTapHandler);
+        this._app.input.onPointerCancel.remove(this._onPointerCancelHandler);
+        this._app.input.onPointerLeave.remove(this._onPointerLeaveHandler);
         this._lastHit.clear();
         this._pending.clear();
         this._capturedPointers.clear();
@@ -15396,7 +15987,7 @@ class InteractionManager {
     /**
      * Process all pending pointer events accumulated since the last frame.
      * Must be called once per frame from {@link Application.update}, after
-     * `inputManager.update()` has run (so signals are already dispatched and
+     * `input.update()` has run (so signals are already dispatched and
      * queued here) and before game-state updates so that user listeners on
      * `onPointerDown` etc. fire before per-frame logic mutates state.
      *
@@ -18469,14 +19060,86 @@ const parseTimestamp = (value) => {
     }
     return seconds;
 };
+const validAlignValues = new Set(['start', 'center', 'end', 'left', 'right']);
+const validLineAlignValues = new Set(['start', 'center', 'end']);
+const validPositionAlignValues = new Set(['auto', 'line-left', 'center', 'line-right']);
+/**
+ * Parses the WebVTT cue-settings tail (`align:center line:80% position:50%`)
+ * and applies each recognized setting to the supplied {@link VTTCue}.
+ *
+ * Unknown keys, malformed values, and unknown enum members are silently
+ * skipped so that one bad token does not invalidate an otherwise valid cue.
+ * Percent signs on numeric values are tolerated and stripped.
+ *
+ * @internal
+ */
+const applyCueSettings = (cue, settings) => {
+    if (!settings) {
+        return;
+    }
+    for (const token of settings.split(/\s+/)) {
+        const colonIndex = token.indexOf(':');
+        if (colonIndex === -1) {
+            continue;
+        }
+        const name = token.slice(0, colonIndex);
+        const value = token.slice(colonIndex + 1);
+        switch (name) {
+            case 'vertical':
+                if (value === 'rl' || value === 'lr' || value === '') {
+                    cue.vertical = value;
+                }
+                break;
+            case 'line': {
+                if (value === 'auto') {
+                    cue.line = 'auto';
+                }
+                else {
+                    const [linePart, alignPart] = value.split(',');
+                    const num = parseFloat(linePart);
+                    if (!Number.isNaN(num)) {
+                        cue.line = num;
+                    }
+                    if (alignPart !== undefined && validLineAlignValues.has(alignPart)) {
+                        cue.lineAlign = alignPart;
+                    }
+                }
+                break;
+            }
+            case 'position': {
+                const [posPart, alignPart] = value.split(',');
+                const num = parseFloat(posPart);
+                if (!Number.isNaN(num)) {
+                    cue.position = num;
+                }
+                if (alignPart !== undefined && validPositionAlignValues.has(alignPart)) {
+                    cue.positionAlign = alignPart;
+                }
+                break;
+            }
+            case 'size': {
+                const num = parseFloat(value);
+                if (!Number.isNaN(num)) {
+                    cue.size = num;
+                }
+                break;
+            }
+            case 'align':
+                if (validAlignValues.has(value)) {
+                    cue.align = value;
+                }
+                break;
+        }
+    }
+};
 /**
  * {@link AssetFactory} implementation that parses WebVTT (`.vtt`) subtitle and
  * caption files and produces an array of {@link VTTCue} instances.
  *
  * The parser handles CRLF and CR line endings, skips the `WEBVTT` header and
- * any metadata blocks, and supports optional cue settings on the timestamp
- * line. Inline cue settings are stripped; only start time, end time, and cue
- * text are preserved.
+ * any metadata blocks, and applies optional cue settings (`align`, `line`,
+ * `position`, `size`, `vertical`) on the timestamp line directly to the
+ * resulting {@link VTTCue}.
  */
 class VttFactory extends AbstractAssetFactory {
     storageName = 'vtt';
@@ -18506,8 +19169,11 @@ class VttFactory extends AbstractAssetFactory {
                 const arrowIndex = line.indexOf('-->');
                 const startStr = line.slice(0, arrowIndex).trim();
                 const rest = line.slice(arrowIndex + 3).trim();
-                // rest may have cue settings after the end timestamp
-                const endStr = rest.split(/\s+/)[0];
+                // rest contains the end timestamp followed by optional cue
+                // settings (align, line, position, size, vertical).
+                const restTokens = rest.split(/\s+/);
+                const endStr = restTokens[0];
+                const settingsString = restTokens.slice(1).join(' ');
                 const start = parseTimestamp(startStr);
                 const end = parseTimestamp(endStr);
                 i++;
@@ -18516,7 +19182,9 @@ class VttFactory extends AbstractAssetFactory {
                     textLines.push(lines[i]);
                     i++;
                 }
-                cues.push(new VTTCue(start, end, textLines.join('\n')));
+                const cue = new VTTCue(start, end, textLines.join('\n'));
+                applyCueSettings(cue, settingsString);
+                cues.push(cue);
             }
             else {
                 i++;
@@ -18615,6 +19283,53 @@ function describeType(type) {
     return type.name.length > 0 ? type.name : '(anonymous type)';
 }
 
+/**
+ * {@link CacheStrategy} that checks every provided {@link CacheStore} before
+ * falling back to the network.
+ *
+ * On a cache hit the stored value is fed directly to
+ * {@link AssetFactory.create | factory.create}; if that throws (stale or
+ * corrupt entry) the entry is deleted and the next store is tried. Only once
+ * all stores miss does the strategy fetch from the network and write the
+ * processed source back to every store. Quota or serialisation errors during
+ * write are swallowed silently so that a full storage can never prevent an
+ * asset from loading.
+ *
+ * Returns the fully constructed resource — callers do not need to call
+ * {@link AssetFactory.create} again.
+ */
+class CacheFirstStrategy {
+    async resolve(request, stores) {
+        const { storageName, key, url, requestOptions, factory, options } = request;
+        for (const store of stores) {
+            const cached = await store.load(storageName, key);
+            if (cached !== null && cached !== undefined) {
+                try {
+                    return await factory.create(cached, options);
+                }
+                catch {
+                    await store.delete(storageName, key);
+                }
+            }
+        }
+        const response = await fetch(url, requestOptions);
+        if (!response.ok) {
+            throw new Error(`Failed to fetch "${url}" (${response.status} ${response.statusText}).`);
+        }
+        const source = await factory.process(response);
+        const resource = await factory.create(source, options);
+        for (const store of stores) {
+            try {
+                await store.save(storageName, key, source);
+            }
+            catch {
+                // Quota exceeded or non-cloneable value — continue without caching.
+            }
+        }
+        return resource;
+    }
+}
+
 // ---------------------------------------------------------------------------
 // Loader
 // ---------------------------------------------------------------------------
@@ -18653,6 +19368,7 @@ class Loader {
     _typeIds = new WeakMap();
     _preventStoreKeys = new Set();
     _stores;
+    _cacheStrategy;
     _resourcePath;
     _requestOptions;
     _concurrency;
@@ -18677,6 +19393,7 @@ class Loader {
         this._stores = options.cache
             ? (Array.isArray(options.cache) ? options.cache : [options.cache])
             : [];
+        this._cacheStrategy = options.cacheStrategy ?? new CacheFirstStrategy();
         this._registerBuiltinFactories();
     }
     // -----------------------------------------------------------------------
@@ -19037,45 +19754,24 @@ class Loader {
     async _fetch(type, alias, path, options) {
         const factory = this._registry.resolve(type);
         const url = this._resolveUrl(path);
-        let source = null;
-        // Check caches
-        for (const store of this._stores) {
-            source = await store.load(factory.storageName, alias);
-            if (source !== null && source !== undefined) {
-                try {
-                    const resource = await factory.create(source, options);
-                    this._storeResource(type, alias, resource);
-                    return resource;
-                }
-                catch {
-                    await store.delete(factory.storageName, alias);
-                    source = null;
-                }
-            }
-        }
-        // Network fetch
-        const response = await fetch(url, this._requestOptions);
-        if (!response.ok) {
-            throw new Error(`Failed to fetch "${alias}" from "${url}" (${response.status} ${response.statusText}).`);
+        try {
+            const resource = await this._cacheStrategy.resolve({
+                storageName: factory.storageName,
+                key: alias,
+                url,
+                requestOptions: this._requestOptions,
+                factory,
+                options,
+            }, this._stores);
+            this._storeResource(type, alias, resource);
+            return resource;
         }
-        source = await factory.process(response);
-        const resource = await factory.create(source, options).catch((error) => {
-            const cause = error instanceof Error ? error : new Error(String(error));
-            throw new Error(`Failed to create "${alias}" from "${url}": ${cause.message}`, {
-                cause,
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            throw new Error(`Failed to load "${alias}" from "${url}": ${message}`, {
+                cause: error,
             });
-        });
-        // Write to caches
-        for (const store of this._stores) {
-            try {
-                await store.save(factory.storageName, alias, source);
-            }
-            catch {
-                // Quota exceeded or non-cloneable — continue without caching.
-            }
         }
-        this._storeResource(type, alias, resource);
-        return resource;
     }
     // -----------------------------------------------------------------------
     // Internal — background queue
@@ -19322,6 +20018,7 @@ const defaultAppSettings = {
     spriteRendererBatchSize: 4096, // ~ 262kb
     particleRendererBatchSize: 8192, // ~ 1.18mb
     gamepadDefinitions: [],
+    gamepadSlotStrategy: 'sticky',
     pointerDistanceThreshold: 10,
     webglAttributes: {
         alpha: false,
@@ -19367,7 +20064,7 @@ class Application {
     options;
     canvas;
     loader;
-    inputManager;
+    input;
     interaction;
     sceneManager;
     tweens = new TweenManager();
@@ -19409,7 +20106,7 @@ class Application {
         });
         this._backendType = this.resolveInitialBackendType();
         this._backend = this.createBackend(this._backendType);
-        this.inputManager = new InputManager(this);
+        this.input = new InputManager(this);
         this.interaction = new InteractionManager(this);
         this.sceneManager = new SceneManager(this);
         this._updateHandler = this.update.bind(this);
@@ -19418,7 +20115,7 @@ class Application {
             this._documentVisible = document.visibilityState === 'visible';
             document.addEventListener('visibilitychange', this._visibilityChangeHandler);
         }
-        this.inputManager.onCanvasFocusChange.add((focused) => {
+        this.input.onCanvasFocusChange.add((focused) => {
             this.onCanvasFocusChange.dispatch(focused);
         });
         this.onVisibilityChange.add((visible) => {
@@ -19455,7 +20152,7 @@ class Application {
         return this._capabilities;
     }
     get canvasFocused() {
-        return this.inputManager.canvasFocused;
+        return this.input.canvasFocused;
     }
     get documentVisible() {
         return this._documentVisible;
@@ -19513,7 +20210,7 @@ class Application {
             const frameDelta = this._frameClock.elapsedTime;
             const frameStart = performance.now();
             this.backend.resetStats();
-            this.inputManager.update();
+            this.input.update();
             this.interaction.update();
             getAudioManager().update();
             this.tweens.update(frameDelta.seconds);
@@ -19586,7 +20283,7 @@ class Application {
         this.stop();
         this.loader.destroy();
         this.interaction.destroy();
-        this.inputManager.destroy();
+        this.input.destroy();
         this.tweens.destroy();
         this._backend.destroy();
         this.sceneManager.destroy();
@@ -19649,6 +20346,41 @@ class Application {
     }
 }
 
+/**
+ * Scene-bound input proxy that automatically disposes its bindings when
+ * the owning scene unloads. Created lazily on first access via
+ * {@link Scene.inputs}; do not instantiate directly.
+ */
+class SceneInputs {
+    _scene;
+    _bindings = new Set();
+    constructor(_scene) {
+        this._scene = _scene;
+    }
+    onStart(channel, callback, options) {
+        return this._track(this._scene.app.input.onStart(channel, callback, options));
+    }
+    onActive(channel, callback, options) {
+        return this._track(this._scene.app.input.onActive(channel, callback, options));
+    }
+    onStop(channel, callback, options) {
+        return this._track(this._scene.app.input.onStop(channel, callback, options));
+    }
+    onTrigger(channel, callback, options) {
+        return this._track(this._scene.app.input.onTrigger(channel, callback, options));
+    }
+    /** @internal Called by Scene.destroy. */
+    _disposeAll() {
+        for (const binding of Array.from(this._bindings)) {
+            binding.unbind();
+        }
+        this._bindings.clear();
+    }
+    _track(binding) {
+        this._bindings.add(binding);
+        return binding;
+    }
+}
 /**
  * A scene's lifecycle host. Subclass to define scene behavior:
  *
@@ -19672,6 +20404,7 @@ class Scene {
     _root = new Container();
     _stackMode = 'overlay';
     _inputMode = 'capture';
+    _inputs = null;
     get app() {
         return this._app;
     }
@@ -19694,6 +20427,24 @@ class Scene {
     get root() {
         return this._root;
     }
+    /**
+     * Scene-bound input registry. Bindings created via
+     * `this.inputs.onTrigger(...)` etc. are automatically disposed when the
+     * scene unloads — no manual cleanup required.
+     *
+     * Lazily instantiated on first access; throws if accessed before
+     * {@link Scene.app} is set (i.e. before the scene is registered with
+     * a {@link SceneManager}).
+     */
+    get inputs() {
+        if (this._inputs === null) {
+            if (this._app === null) {
+                throw new Error('Scene.inputs is unavailable before the scene is attached to an Application.');
+            }
+            this._inputs = new SceneInputs(this);
+        }
+        return this._inputs;
+    }
     get stackMode() {
         return this._stackMode;
     }
@@ -19790,47 +20541,13 @@ class Scene {
         // override in subclass
     }
     destroy() {
+        this._inputs?._disposeAll();
+        this._inputs = null;
         this._root.destroy();
         this._app = null;
     }
 }
 
-/**
- * {@link Clock} variant with a fixed limit. Inherits start/stop/reset/restart
- * semantics; adds {@link Timer.expired} (true once `elapsedTime >= limit`)
- * and remaining-time accessors. Useful for cooldowns, delays, and any timed
- * gating logic where you want to ask "is the duration up?" each frame.
- */
-class Timer extends Clock {
-    _limit;
-    constructor(limit, autoStart = false) {
-        super();
-        this._limit = limit.clone();
-        if (autoStart) {
-            this.restart();
-        }
-    }
-    set limit(limit) {
-        this._limit.copy(limit);
-    }
-    /** `true` once the elapsed time has reached or exceeded the configured limit. */
-    get expired() {
-        return this.elapsedMilliseconds >= this._limit.milliseconds;
-    }
-    get remainingMilliseconds() {
-        return Math.max(0, this._limit.milliseconds - this.elapsedMilliseconds);
-    }
-    get remainingSeconds() {
-        return this.remainingMilliseconds / Time.seconds;
-    }
-    get remainingMinutes() {
-        return this.remainingMilliseconds / Time.minutes;
-    }
-    get remainingHours() {
-        return this.remainingMilliseconds / Time.hours;
-    }
-}
-
 /**
  * Lightweight visualisation analyser backed by a Web Audio AnalyserNode.
  *
@@ -23027,22 +23744,22 @@ const basePositions = new Map([
     ['RightStick', [0.62, 0.66]],
 ]);
 const channelMap = new Map([
-    ['ButtonNorth', GamepadChannel.ButtonNorth],
-    ['ButtonWest', GamepadChannel.ButtonWest],
-    ['ButtonEast', GamepadChannel.ButtonEast],
-    ['ButtonSouth', GamepadChannel.ButtonSouth],
-    ['LeftShoulder', GamepadChannel.LeftShoulder],
-    ['RightShoulder', GamepadChannel.RightShoulder],
-    ['LeftTrigger', GamepadChannel.LeftTrigger],
-    ['RightTrigger', GamepadChannel.RightTrigger],
-    ['Select', GamepadChannel.Select],
-    ['Start', GamepadChannel.Start],
-    ['LeftStick', GamepadChannel.LeftStick],
-    ['RightStick', GamepadChannel.RightStick],
-    ['DPadUp', GamepadChannel.DPadUp],
-    ['DPadDown', GamepadChannel.DPadDown],
-    ['DPadLeft', GamepadChannel.DPadLeft],
-    ['DPadRight', GamepadChannel.DPadRight],
+    ['ButtonNorth', GamepadButton.North],
+    ['ButtonWest', GamepadButton.West],
+    ['ButtonEast', GamepadButton.East],
+    ['ButtonSouth', GamepadButton.South],
+    ['LeftShoulder', GamepadButton.LeftShoulder],
+    ['RightShoulder', GamepadButton.RightShoulder],
+    ['LeftTrigger', GamepadButton.LeftTrigger],
+    ['RightTrigger', GamepadButton.RightTrigger],
+    ['Select', GamepadButton.Select],
+    ['Start', GamepadButton.Start],
+    ['LeftStick', GamepadButton.LeftStick],
+    ['RightStick', GamepadButton.RightStick],
+    ['DPadUp', GamepadButton.DPadUp],
+    ['DPadDown', GamepadButton.DPadDown],
+    ['DPadLeft', GamepadButton.DPadLeft],
+    ['DPadRight', GamepadButton.DPadRight],
 ]);
 const genericLabels = new Map([
     ['ButtonNorth', 'North'],
@@ -23109,6 +23826,7 @@ const promptLabelsByFamily = new Map([
     [GamepadMappingFamily.JoyConRight, switchLabels],
     [GamepadMappingFamily.GameCube, genericLabels],
     [GamepadMappingFamily.SteamController, genericLabels],
+    [GamepadMappingFamily.SteamDeck, genericLabels],
     [GamepadMappingFamily.ArcadeStick, genericLabels],
 ]);
 /**
@@ -23117,7 +23835,7 @@ const promptLabelsByFamily = new Map([
  * Provides the canonical set of prompt controls, their normalised [x, y] positions
  * on a generic controller silhouette, device-family label strings (e.g. "A" for
  * Xbox, "Cross" for PlayStation, "B" for Switch), and the mapping from prompt
- * control names to {@link GamepadChannel} values.
+ * control names to {@link GamepadButton} channel values.
  */
 class GamepadPromptLayouts {
     /** Complete ordered list of every {@link GamepadPromptControl} token. */
@@ -23158,98 +23876,14 @@ class GamepadPromptLayouts {
     }
     /**
      * Returns the static mapping from each {@link GamepadPromptControl} to its
-     * corresponding {@link GamepadChannel}. The composite `'DPad'` control has no
-     * channel entry and is absent from the returned map.
+     * corresponding {@link GamepadButton} channel. The composite `'DPad'`
+     * control has no channel entry and is absent from the returned map.
      */
     static getControlChannelMap() {
         return channelMap;
     }
 }
 
-/**
- * Bind one or more input channels (keyboard keys, gamepad buttons, gamepad
- * axes) to a set of high-level events: `onStart` (became active),
- * `onStop` (became inactive), `onActive` (per-frame while active), and
- * `onTrigger` (released within the threshold window — a "tap"). The current
- * raw value is the max across all subscribed channels.
- *
- * Construct ad-hoc, or via {@link InputManager.add}. Driven by the
- * {@link InputManager} update loop which feeds the unified channel buffer.
- *
- * @example
- * ```ts
- * const jump = new Input([Keyboard.Space, GamepadChannel.FaceA], {
- *     onTrigger: () => player.jump(),
- * });
- * ```
- */
-class Input {
-    static triggerThreshold = 300;
-    channels = new Set();
-    triggerTimer;
-    valueState = 0;
-    onStart = new Signal();
-    onStop = new Signal();
-    onActive = new Signal();
-    onTrigger = new Signal();
-    constructor(channels, { onStart, onStop, onActive, onTrigger, context, threshold } = {}) {
-        this.channels = new Set(Array.isArray(channels) ? channels : [channels]);
-        this.triggerTimer = new Timer(milliseconds(threshold ?? Input.triggerThreshold));
-        if (onStart) {
-            this.onStart.add(onStart, context);
-        }
-        if (onStop) {
-            this.onStop.add(onStop, context);
-        }
-        if (onActive) {
-            this.onActive.add(onActive, context);
-        }
-        if (onTrigger) {
-            this.onTrigger.add(onTrigger, context);
-        }
-    }
-    get activeChannels() {
-        return this.channels;
-    }
-    get value() {
-        return this.valueState;
-    }
-    /**
-     * Read the latest values from the unified channel buffer and dispatch
-     * the appropriate Signals. Called once per frame by {@link InputManager}.
-     * No-op for inputs not bound to any channel.
-     */
-    update(channels) {
-        this.valueState = 0;
-        for (const channel of this.channels) {
-            this.valueState = Math.max(channels[channel], this.valueState);
-        }
-        if (this.valueState) {
-            if (!this.triggerTimer.running) {
-                this.triggerTimer.restart();
-                this.onStart.dispatch(this.valueState);
-            }
-            this.onActive.dispatch(this.valueState);
-        }
-        else if (this.triggerTimer.running) {
-            this.onStop.dispatch(this.valueState);
-            if (!this.triggerTimer.expired) {
-                this.onTrigger.dispatch(this.valueState);
-            }
-            this.triggerTimer.stop();
-        }
-        return this;
-    }
-    destroy() {
-        this.channels.clear();
-        this.triggerTimer.destroy();
-        this.onStart.destroy();
-        this.onStop.destroy();
-        this.onActive.destroy();
-        this.onTrigger.destroy();
-    }
-}
-
 /**
  * Triangulate a simple 2D polygon by ear-clipping.
  *
@@ -27370,50 +28004,6 @@ class WebGpuShaderFilter extends Filter {
     }
 }
 
-/**
- * {@link CacheStrategy} that checks every provided {@link CacheStore} before
- * falling back to the network.
- *
- * On a cache hit the stored value is validated by calling
- * {@link AssetFactory.create | factory.create}; if that throws (stale or
- * corrupt entry) the entry is deleted and the next store is tried. Only once
- * all stores miss does the strategy fetch from the network and write the
- * result back to every store. Quota or serialisation errors during write are
- * swallowed silently so that a full storage can never prevent an asset from
- * loading.
- */
-class CacheFirstStrategy {
-    async resolve(request, stores) {
-        const { storageName, key, url, requestOptions, factory } = request;
-        for (const store of stores) {
-            const cached = await store.load(storageName, key);
-            if (cached !== null && cached !== undefined) {
-                try {
-                    await factory.create(cached);
-                    return cached;
-                }
-                catch {
-                    await store.delete(storageName, key);
-                }
-            }
-        }
-        const response = await fetch(url, requestOptions);
-        if (!response.ok) {
-            throw new Error(`Failed to fetch "${url}" (${response.status} ${response.statusText}).`);
-        }
-        const source = await factory.process(response);
-        for (const store of stores) {
-            try {
-                await store.save(storageName, key, source);
-            }
-            catch {
-                // Quota exceeded or non-cloneable value — continue without caching.
-            }
-        }
-        return source;
-    }
-}
-
 /**
  * {@link CacheStrategy} that always fetches from the network and never reads
  * from or writes to any {@link CacheStore}.
@@ -27421,14 +28011,19 @@ class CacheFirstStrategy {
  * Useful for assets that must always be fresh (e.g. live configuration files)
  * or for environments where persistent storage is unavailable. The `stores`
  * argument is accepted but intentionally ignored.
+ *
+ * Returns the fully constructed resource — callers do not need to call
+ * {@link AssetFactory.create} again.
  */
 class NetworkOnlyStrategy {
     async resolve(request, _stores) {
-        const response = await fetch(request.url, request.requestOptions);
+        const { url, requestOptions, factory, options } = request;
+        const response = await fetch(url, requestOptions);
         if (!response.ok) {
-            throw new Error(`Failed to fetch "${request.url}" (${response.status} ${response.statusText}).`);
+            throw new Error(`Failed to fetch "${url}" (${response.status} ${response.statusText}).`);
         }
-        return request.factory.process(response);
+        const source = await factory.process(response);
+        return factory.create(source, options);
     }
 }
 
@@ -27632,5 +28227,5 @@ class IndexedDbStore {
     }
 }
 
-export { AbstractAssetFactory, AbstractMedia, AbstractWebGl2BatchedRenderer, AbstractWebGl2Renderer, AbstractWebGpuRenderer, AnimatedSprite, Application, ApplicationStatus, ArcadeStickGamepadMapping, AudioAnalyser, AudioBus, AudioFilter, AudioListener, AudioManager, BeatDetector, BinaryFactory, BlendModes, BlurFilter, Bounds, BufferTypes, BufferUsage, BundleLoadError, CacheFirstStrategy, CallbackRenderPass, Capabilities, ChannelOffset, ChannelSize, ChorusFilter, Circle, Clock, CollisionType, Color, ColorAffector, ColorFilter, CompressorFilter, Container, DelayFilter, Drawable, DuckingFilter, DynamicGlyphAtlas, Ease, Ellipse, Envelope, EqualizerFilter, FactoryRegistry, Filter, Flags, FontFactory, ForceAffector, GameCubeGamepadMapping, Gamepad, GamepadChannel, GamepadControl, GamepadMapping, GamepadMappingFamily, GamepadPromptLayouts, GenericDualAnalogGamepadMapping, GranularFilter, Graphics, HighpassFilter, ImageFactory, IndexedDbDatabase, IndexedDbStore, Input, InputManager, InteractionEvent, InteractionManager, Interval, JoyConLeftGamepadMapping, JoyConRightGamepadMapping, Json, JsonFactory, Keyboard, Line, Loader, LowpassFilter, Matrix, Mesh, Music, MusicFactory, NetworkOnlyStrategy, ObservableSize, ObservableVector, OscillatorSound, Particle, ParticleOptions, ParticleSystem, PitchShiftFilter, PlayStationGamepadMapping, Pointer, PointerState, PointerStateFlag, PolarVector, Polygon, Quadtree, Random, Rectangle, RenderBackendType, RenderNode, RenderTarget, RenderTargetPass, RenderTexture, RendererRegistry, RenderingPrimitives, ReverbFilter, Sampler, ScaleAffector, ScaleModes, Scene, SceneManager, SceneNode, Segment, Shader, ShaderAttribute, ShaderPrimitives, ShaderUniform, Signal, Size, Sound, SoundFactory, SoundPoolStrategy, Sprite, SpriteFlags, Spritesheet, SteamControllerGamepadMapping, SvgAsset, SvgFactory, SwitchProGamepadMapping, Text, TextAsset, TextFactory, TextStyle, Texture, TextureFactory, Time, Timer, TorqueAffector, Tween, TweenManager, TweenState, UniversalEmitter, Vector, Video, VideoFactory, View, ViewFlags, VocoderFilter, VoronoiRegion, VttAsset, VttFactory, WasmFactory, WebGl2Backend, WebGl2MeshRenderer, WebGl2ParticleRenderer, WebGl2RenderBuffer, WebGl2ShaderBlock, WebGl2ShaderFilter, WebGl2SpriteRenderer, WebGl2VertexArrayObject, WebGpuBackend, WebGpuMeshRenderer, WebGpuParticleRenderer, WebGpuShaderFilter, WebGpuSpriteRenderer, WorkletFilter, WrapModes, XboxGamepadMapping, bezierCurveTo, buildCircle, buildEllipse, buildLine, buildPath, buildPolygon, buildRectangle, buildStar, builtInGamepadDefinitions, canvasSourceToDataUrl, clamp, createRenderStats, createWebGl2ShaderProgram, crossFade, decodeAudioData, defineAssetManifest, degreesPerRadian, degreesToRadians, determineMimeType, emptyArrayBuffer, getAudioContext, getAudioManager, getCanvasSourceSize, getCollisionCircleCircle, getCollisionCircleRectangle, getCollisionEllipseCircle, getCollisionEllipseRectangle, getCollisionPolygonCircle, getCollisionRectangleRectangle, getCollisionSat, getDistance, getOfflineAudioContext, getPreciseTime, getTextureSourceSize, getVoronoiRegion$1 as getVoronoiRegion, getWebGpuBlendState, hours, inRange, intersectionCircleCircle, intersectionCircleEllipse, intersectionCirclePoly, intersectionEllipseEllipse, intersectionEllipsePoly, intersectionLineCircle, intersectionLineEllipse, intersectionLineLine, intersectionLinePoly, intersectionLineRect, intersectionPointCircle, intersectionPointEllipse, intersectionPointLine, intersectionPointPoint, intersectionPointPoly, intersectionPointRect, intersectionPolyPoly, intersectionRectCircle, intersectionRectEllipse, intersectionRectPoly, intersectionRectRect, intersectionSat, isAudioContextReady, isPowerOfTwo, layoutText, lerp, matchesIds, maxPointers, milliseconds, minutes, noop$1 as noop, onAudioContextReady, parseGamepadDescriptor, pointerSlotSize, quadraticCurveTo, radiansPerDegree, radiansToDegrees, rand, registerWorkletProcessor, removeArrayItems, resetRenderStats, resolveDefinition, resolveGamepadDefinition, seconds, sign, stopEvent, substepSweep, supportsCodec, supportsEventOptions, supportsIndexedDb, supportsPointerEvents, supportsTouchEvents, supportsWebAudio, sweepCircleAgainst, sweepCircleVsCircle, sweepCircleVsRectangle, sweepRectangle, sweepRectangleAgainst, tau, trimRotation, upgradeFragmentShaderToGl300, webGl2PrimitiveArrayConstructors, webGl2PrimitiveByteSizeMapping, webGl2PrimitiveTypeNames };
+export { AbstractAssetFactory, AbstractMedia, AbstractWebGl2BatchedRenderer, AbstractWebGl2Renderer, AbstractWebGpuRenderer, AnimatedSprite, Application, ApplicationStatus, ArcadeStickGamepadMapping, AudioAnalyser, AudioBus, AudioFilter, AudioListener, AudioManager, BeatDetector, BinaryFactory, BlendModes, BlurFilter, Bounds, BufferTypes, BufferUsage, BundleLoadError, CacheFirstStrategy, CallbackRenderPass, Capabilities, ChannelOffset, ChannelSize, ChorusFilter, Circle, Clock, CollisionType, Color, ColorAffector, ColorFilter, CompressorFilter, Container, DelayFilter, Drawable, DuckingFilter, DynamicGlyphAtlas, Ease, Ellipse, Envelope, EqualizerFilter, FactoryRegistry, Filter, Flags, FontFactory, ForceAffector, GameCubeGamepadMapping, Gamepad, GamepadAxis, GamepadButton, GamepadMapping, GamepadMappingFamily, GamepadPromptLayouts, GenericDualAnalogGamepadMapping, GranularFilter, Graphics, HighpassFilter, ImageFactory, IndexedDbDatabase, IndexedDbStore, InputBinding, InputManager, InteractionEvent, InteractionManager, Interval, JoyConLeftGamepadMapping, JoyConRightGamepadMapping, Json, JsonFactory, Keyboard, Line, Loader, LowpassFilter, Matrix, Mesh, Music, MusicFactory, NetworkOnlyStrategy, ObservableSize, ObservableVector, OscillatorSound, Particle, ParticleOptions, ParticleSystem, PitchShiftFilter, PlayStationGamepadMapping, Pointer, PointerState, PointerStateFlag, PolarVector, Polygon, Quadtree, Random, Rectangle, RenderBackendType, RenderNode, RenderTarget, RenderTargetPass, RenderTexture, RendererRegistry, RenderingPrimitives, ReverbFilter, Sampler, ScaleAffector, ScaleModes, Scene, SceneManager, SceneNode, Segment, Shader, ShaderAttribute, ShaderPrimitives, ShaderUniform, Signal, Size, Sound, SoundFactory, SoundPoolStrategy, Sprite, SpriteFlags, Spritesheet, SteamControllerGamepadMapping, SteamDeckGamepadMapping, SvgAsset, SvgFactory, SwitchProGamepadMapping, Text, TextAsset, TextFactory, TextStyle, Texture, TextureFactory, Time, Timer, TorqueAffector, Tween, TweenManager, TweenState, UniversalEmitter, Vector, Video, VideoFactory, View, ViewFlags, VocoderFilter, VoronoiRegion, VttAsset, VttFactory, WasmFactory, WebGl2Backend, WebGl2MeshRenderer, WebGl2ParticleRenderer, WebGl2RenderBuffer, WebGl2ShaderBlock, WebGl2ShaderFilter, WebGl2SpriteRenderer, WebGl2VertexArrayObject, WebGpuBackend, WebGpuMeshRenderer, WebGpuParticleRenderer, WebGpuShaderFilter, WebGpuSpriteRenderer, WorkletFilter, WrapModes, XboxGamepadMapping, bezierCurveTo, buildCircle, buildEllipse, buildLine, buildPath, buildPolygon, buildRectangle, buildStar, builtInGamepadDefinitions, canvasSourceToDataUrl, clamp, createRenderStats, createWebGl2ShaderProgram, crossFade, decodeAudioData, defineAssetManifest, degreesPerRadian, degreesToRadians, determineMimeType, emptyArrayBuffer, getAudioContext, getAudioManager, getCanvasSourceSize, getCollisionCircleCircle, getCollisionCircleRectangle, getCollisionEllipseCircle, getCollisionEllipseRectangle, getCollisionPolygonCircle, getCollisionRectangleRectangle, getCollisionSat, getDistance, getOfflineAudioContext, getPreciseTime, getTextureSourceSize, getVoronoiRegion$1 as getVoronoiRegion, getWebGpuBlendState, hours, inRange, intersectionCircleCircle, intersectionCircleEllipse, intersectionCirclePoly, intersectionEllipseEllipse, intersectionEllipsePoly, intersectionLineCircle, intersectionLineEllipse, intersectionLineLine, intersectionLinePoly, intersectionLineRect, intersectionPointCircle, intersectionPointEllipse, intersectionPointLine, intersectionPointPoint, intersectionPointPoly, intersectionPointRect, intersectionPolyPoly, intersectionRectCircle, intersectionRectEllipse, intersectionRectPoly, intersectionRectRect, intersectionSat, isAudioContextReady, isPowerOfTwo, layoutText, lerp, matchesIds, maxPointers, milliseconds, minutes, noop$1 as noop, onAudioContextReady, parseGamepadDescriptor, pointerSlotSize, quadraticCurveTo, radiansPerDegree, radiansToDegrees, rand, registerWorkletProcessor, removeArrayItems, resetRenderStats, resolveDefinition, resolveGamepadDefinition, seconds, sign, stopEvent, substepSweep, supportsCodec, supportsEventOptions, supportsIndexedDb, supportsPointerEvents, supportsTouchEvents, supportsWebAudio, sweepCircleAgainst, sweepCircleVsCircle, sweepCircleVsRectangle, sweepRectangle, sweepRectangleAgainst, tau, trimRotation, upgradeFragmentShaderToGl300, webGl2PrimitiveArrayConstructors, webGl2PrimitiveByteSizeMapping, webGl2PrimitiveTypeNames };
 //# sourceMappingURL=exo.esm.js.map