@codexo/exojs 0.7.11 → 0.7.13

package/dist/esm/input/InputBinding.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"InputBinding.js","sources":["../../../../src/input/InputBinding.ts"],"sourcesContent":[null],"names":[],"mappings":";;;;AAgCA;;;;;;;;;;;;;;AAcG;MACU,YAAY,CAAA;AACrB;;;;AAIG;AACI,IAAA,OAAO,uBAAuB,GAAG,GAAG;AAE3B,IAAA,QAAQ;AAER,IAAA,OAAO,GAAK,IAAI,MAAM,EAAY;AAClC,IAAA,QAAQ,GAAI,IAAI,MAAM,EAAY;AAClC,IAAA,MAAM,GAAM,IAAI,MAAM,EAAY;AAClC,IAAA,SAAS,GAAG,IAAI,MAAM,EAAY;AAEjC,IAAA,aAAa;AACb,IAAA,SAAS;IAClB,MAAM,GAAG,CAAC;IACV,QAAQ,GAAG,KAAK;AAExB,IAAA,WAAA,CACI,QAA+B,EAC/B,OAAA,GAA+B,EAAE,EACjC,WAA2C,IAAI,EAAA;AAE/C,QAAA,IAAI,CAAC,QAAQ,GAAG,QAAQ;AACxB,QAAA,IAAI,CAAC,aAAa,GAAG,IAAI,KAAK,CAAC,YAAY,CAAC,OAAO,CAAC,SAAS,IAAI,YAAY,CAAC,uBAAuB,CAAC,CAAC;AACvG,QAAA,IAAI,CAAC,SAAS,GAAG,QAAQ;IAC7B;;AAGA,IAAA,IAAW,KAAK,GAAA;QACZ,OAAO,IAAI,CAAC,MAAM;IACtB;;AAGA,IAAA,IAAW,MAAM,GAAA;AACb,QAAA,OAAO,IAAI,CAAC,MAAM,GAAG,CAAC;IAC1B;AAEA;;;;;AAKG;AACI,IAAA,MAAM,CAAC,QAAsB,EAAA;AAChC,QAAA,IAAI,IAAI,CAAC,QAAQ,EAAE;YACf;QACJ;QAEA,IAAI,KAAK,GAAG,CAAC;AAEb,QAAA,KAAK,MAAM,OAAO,IAAI,IAAI,CAAC,QAAQ,EAAE;AACjC,YAAA,MAAM,MAAM,GAAG,QAAQ,CAAC,OAAO,CAAC;AAEhC,YAAA,IAAI,IAAI,CAAC,GAAG,CAAC,MAAM,CAAC,GAAG,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,EAAE;gBACpC,KAAK,GAAG,MAAM;YAClB;QACJ;AAEA,QAAA,IAAI,CAAC,MAAM,GAAG,KAAK;AAEnB,QAAA,IAAI,KAAK,KAAK,CAAC,EAAE;AACb,YAAA,IAAI,CAAC,IAAI,CAAC,aAAa,CAAC,OAAO,EAAE;AAC7B,gBAAA,IAAI,CAAC,aAAa,CAAC,OAAO,EAAE;AAC5B,gBAAA,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAC;YAChC;AAEA,YAAA,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC,KAAK,CAAC;QACjC;AAAO,aAAA,IAAI,IAAI,CAAC,aAAa,CAAC,OAAO,EAAE;AACnC,YAAA,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC,CAAC;AAEvB,YAAA,IAAI,CAAC,IAAI,CAAC,aAAa,CAAC,OAAO,EAAE;AAC7B,gBAAA,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC,CAAC,CAAC;YAC9B;AAEA,YAAA,IAAI,CAAC,aAAa,CAAC,IAAI,EAAE;QAC7B;IACJ;AAEA;;AAEG;IACI,MAAM,GAAA;AACT,QAAA,IAAI,IAAI,CAAC,QAAQ,EAAE;YACf;QACJ;AAEA,QAAA,IAAI,CAAC,QAAQ,GAAG,IAAI;AACpB,QAAA,IAAI,CAAC,SAAS,EAAE,MAAM,CAAC,IAAI,CAAC;AAC5B,QAAA,IAAI,CAAC,aAAa,CAAC,OAAO,EAAE;AAC5B,QAAA,IAAI,CAAC,OAAO,CAAC,OAAO,EAAE;AACtB,QAAA,IAAI,CAAC,QAAQ,CAAC,OAAO,EAAE;AACvB,QAAA,IAAI,CAAC,MAAM,CAAC,OAAO,EAAE;AACrB,QAAA,IAAI,CAAC,SAAS,CAAC,OAAO,EAAE;IAC5B;;;;;"}

package/dist/esm/input/InputManager.d.ts

@@ -2,21 +2,54 @@ import { Vector } from '@/math/Vector';
 import { Signal } from '@/core/Signal';
 import { Gamepad } from './Gamepad';
 import { Pointer } from './Pointer';
+import { InputBinding } from './InputBinding';
 import type { Application } from '@/core/Application';
-import type { Input } from './Input';
+import type { GamepadAxis } from './GamepadAxis';
+import type { GamepadButton } from './GamepadButton';
+import type { InputBindingOptions, InputChannel } from './InputBinding';
+/**
+ * Strategy used by {@link InputManager} when assigning physical gamepads to
+ * slot indices in {@link InputManager.gamepads}.
+ *
+ * - `'sticky'` (default): each physical pad keeps its slot until a new pad
+ *   fills an empty slot. A disconnect leaves a gap; reconnect later fills
+ *   the lowest empty slot. Best for player-stable-binding semantics.
+ * - `'compact'`: on disconnect, higher-numbered slots shift down to keep
+ *   `gamepads[0..N-1]` densely populated. Good for "the first N pads are
+ *   the N players" workflows.
+ */
+export type GamepadSlotStrategy = 'sticky' | 'compact';
+/**
+ * Owns the unified input pipeline for an {@link Application}: keyboard
+ * events, pointer (mouse/touch/pen) events with multi-touch slot
+ * management, gamepad polling with mapping detection, mouse-wheel events,
+ * canvas-focus tracking, and high-level gesture recognition (pinch /
+ * rotate / long-press).
+ *
+ * All raw inputs are written into a shared `Float32Array` channel buffer.
+ * 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.
+ */
 export declare class InputManager {
     private readonly canvas;
     private readonly channels;
-    private readonly inputs;
     private readonly pointers;
-    private readonly gamepadsValue;
-    private readonly gamepadsByIndex;
-    private readonly gamepadSlotsActive;
+    private readonly _gamepads;
+    private readonly gamepadsByBrowserIndex;
+    private readonly bindings;
+    private readonly bindingDetacher;
     private readonly wheelOffset;
     private readonly flags;
     private readonly channelsPressed;
     private readonly channelsReleased;
     private readonly gamepadDefinitions;
+    private readonly slotStrategy;
     private readonly pointerSlots;
     private readonly freeSlots;
     private readonly gestureRecognizer;
@@ -46,9 +79,22 @@ export declare class InputManager {
     readonly onMouseWheel: Signal<[Vector]>;
     readonly onKeyDown: Signal<[number]>;
     readonly onKeyUp: Signal<[number]>;
-    readonly onGamepadConnected: Signal<[Gamepad, Gamepad[]]>;
-    readonly onGamepadDisconnected: Signal<[Gamepad, Gamepad[]]>;
-    readonly onGamepadUpdated: Signal<[Gamepad, Gamepad[]]>;
+    /** Fires when a physical pad connects to any slot. */
+    readonly onGamepadConnected: Signal<[Gamepad]>;
+    /** Fires when a physical pad disconnects from any slot. */
+    readonly onGamepadDisconnected: Signal<[Gamepad]>;
+    /**
+     * 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.
+     */
+    readonly onAnyGamepadReassigned: Signal<[Gamepad, fromSlot: 0 | 1 | 2 | 3]>;
+    /** Fires whenever any pad reports a button press transition. */
+    readonly onAnyGamepadButtonDown: Signal<[Gamepad, GamepadButton, number]>;
+    /** Fires whenever any pad reports a button release transition. */
+    readonly onAnyGamepadButtonUp: Signal<[Gamepad, GamepadButton, number]>;
+    /** Fires whenever any pad reports an axis value change. */
+    readonly onAnyGamepadAxisChange: Signal<[Gamepad, GamepadAxis, number]>;
     /** Fires on every two-touch-pointer move where the distance between them changed. `scale` > 1 = spreading, < 1 = pinching. */
     readonly onPinch: Signal<[scale: number, center: Vector]>;
     /** Fires on every two-touch-pointer move where the angle between them changed. `angleDelta` is in radians. */
@@ -67,13 +113,52 @@ export declare class InputManager {
     } | null;
     get pointersInCanvas(): boolean;
     get canvasFocused(): boolean;
-    get gamepads(): Array<Gamepad>;
-    getGamepad(index: number): Gamepad | null;
-    add(inputs: Input | Array<Input>): this;
-    remove(inputs: Input | Array<Input>): this;
-    clear(destroyInputs?: boolean): this;
+    /**
+     * 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(): readonly [Gamepad, Gamepad, Gamepad, Gamepad];
+    /** The slot strategy active for this `InputManager`. */
+    get gamepadSlotStrategy(): GamepadSlotStrategy;
+    /**
+     * Direct accessor for a single gamepad slot. Equivalent to
+     * `app.input.gamepads[slot]` but reads more clearly at call sites.
+     */
+    getGamepad(slot: 0 | 1 | 2 | 3): Gamepad;
+    /** Subset of {@link gamepads} containing only currently connected pads, in slot order. */
+    get connectedGamepads(): ReadonlyArray<Gamepad>;
+    /** Number of slots currently occupied by a physical gamepad. */
+    get connectedGamepadCount(): number;
+    /** First connected gamepad in slot order, or `null` when no pads are attached. */
+    get firstConnectedGamepad(): Gamepad | null;
+    /** `true` when at least one slot is occupied by a physical gamepad. */
+    get hasGamepad(): boolean;
+    /**
+     * Register a callback fired once when any of `channels` becomes active.
+     * Manual lifecycle — call `.unbind()` on the returned binding to detach.
+     */
+    onStart(channel: InputChannel | ReadonlyArray<InputChannel>, callback: (value: number) => void, options?: InputBindingOptions): InputBinding;
+    /** Register a callback fired every frame while any of `channels` is active. */
+    onActive(channel: InputChannel | ReadonlyArray<InputChannel>, callback: (value: number) => void, options?: InputBindingOptions): InputBinding;
+    /** Register a callback fired once when all of `channels` become inactive. */
+    onStop(channel: InputChannel | ReadonlyArray<InputChannel>, callback: (value: number) => void, options?: InputBindingOptions): InputBinding;
+    /**
+     * Register a callback fired when the input is released within
+     * {@link InputBindingOptions.threshold} ms of activation (a "tap").
+     */
+    onTrigger(channel: InputChannel | ReadonlyArray<InputChannel>, callback: (value: number) => void, options?: InputBindingOptions): InputBinding;
+    /**
+     * 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 binding.
+     */
     update(): this;
     destroy(): void;
+    private createBinding;
+    private resolveExternalChannel;
+    private wireGamepadEvents;
     private _assignSlot;
     private _releaseSlot;
     private handleKeyDown;
@@ -88,18 +173,12 @@ export declare class InputManager {
     private handleCanvasFocus;
     private handleCanvasBlur;
     private handleWindowBlur;
-    /**
-     * 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.
-     */
     private releaseAllKeyboardChannels;
     private addEventListeners;
     private removeEventListeners;
     private updateGamepads;
-    private insertGamepadByIndex;
+    private assignSlotForNewPad;
+    private handleGamepadDisconnect;
     private updateEvents;
     private updatePointerEvents;
 }

package/dist/esm/input/InputManager.js

@@ -7,8 +7,10 @@ import { ChannelSize, maxPointers, ChannelOffset } from './types.js';
 import { Gamepad } from './Gamepad.js';
 import { PointerState, Pointer, PointerStateFlag } from './Pointer.js';
 import { GestureRecognizer } from './GestureRecognizer.js';
+import { InputBinding } from './InputBinding.js';
 import { builtInGamepadDefinitions, resolveGamepadDefinition } from './GamepadDefinitions.js';
 
+const gamepadSlots = 4;
 var InputManagerFlag;
 (function (InputManagerFlag) {
     InputManagerFlag[InputManagerFlag["None"] = 0] = "None";
@@ -17,21 +19,39 @@ var InputManagerFlag;
     InputManagerFlag[InputManagerFlag["MouseWheel"] = 4] = "MouseWheel";
     InputManagerFlag[InputManagerFlag["PointerUpdate"] = 8] = "PointerUpdate";
 })(InputManagerFlag || (InputManagerFlag = {}));
+/**
+ * Owns the unified input pipeline for an {@link Application}: keyboard
+ * events, pointer (mouse/touch/pen) events with multi-touch slot
+ * management, gamepad polling with mapping detection, mouse-wheel events,
+ * canvas-focus tracking, and high-level gesture recognition (pinch /
+ * rotate / long-press).
+ *
+ * All raw inputs are written into a shared `Float32Array` channel buffer.
+ * 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.
+ */
 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;
@@ -60,9 +80,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. */
@@ -70,16 +103,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();
     }
     /**
@@ -93,7 +135,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 };
@@ -108,41 +149,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;
     }
-    add(inputs) {
-        if (Array.isArray(inputs)) {
-            inputs.forEach((input) => this.add(input));
-            return this;
+    /**
+     * Direct accessor for a single gamepad slot. Equivalent to
+     * `app.input.gamepads[slot]` but reads more clearly at call sites.
+     */
+    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;
     }
-    remove(inputs) {
-        if (Array.isArray(inputs)) {
-            inputs.forEach((input) => this.remove(input));
-            return this;
+    /** Number of slots currently occupied by a physical gamepad. */
+    get connectedGamepadCount() {
+        let count = 0;
+        for (const pad of this._gamepads) {
+            if (pad.connected) {
+                count++;
+            }
         }
-        this.inputs.delete(inputs);
-        return this;
+        return count;
     }
-    clear(destroyInputs = false) {
-        if (destroyInputs) {
-            for (const input of this.inputs) {
-                input.destroy();
+    /** 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;
             }
         }
-        this.inputs.clear();
-        return this;
+        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;
+    }
+    /** 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;
+    }
+    /**
+     * 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;
+    }
+    /**
+     * 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 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();
@@ -155,12 +258,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();
+        }
+        for (const binding of Array.from(this.bindings)) {
+            binding.unbind();
         }
-        this.inputs.clear();
-        this.gamepadsByIndex.clear();
-        this.gamepadsValue.length = 0;
+        this.bindings.clear();
+        this.gamepadsByBrowserIndex.clear();
         this.channelsPressed.length = 0;
         this.channelsReleased.length = 0;
         this.pointerSlots.clear();
@@ -180,18 +285,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);
@@ -201,14 +328,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;
         }
@@ -216,9 +339,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) {
@@ -234,7 +354,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);
@@ -259,10 +379,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) {
@@ -322,13 +438,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;
@@ -377,49 +486,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)) {