@flighthq/input 0.5.0-next.1944.cd6b6e7 → 0.5.1-edge.638.d4dbd4e

package/dist/inputManager.js

@@ -47,182 +47,29 @@ export function applyGamepadStickDeadZone(out, x, y, deadZone) {
     out.x = x * scale;
     out.y = y * scale;
 }
-export function attachGamepadInput(manager, target, options) {
-    const onGamepadConnected = (e) => {
-        if (!manager.enabled)
-            return;
-        const pad = e.gamepad;
-        const prev = getOrCreateGamepadPollState(manager);
-        prev.axes.set(pad.index, Array.from(pad.axes));
-        prev.buttons.set(pad.index, Array.from(pad.buttons, (b) => b.pressed));
-        _connectData.gamepad = pad.index;
-        _connectData.id = pad.id;
-        _connectData.mapping = pad.mapping === 'standard' ? 'standard' : pad.mapping === '' ? '' : 'raw';
-        emitSignal(manager.onGamepadConnect, _connectData);
-    };
-    const onGamepadDisconnected = (e) => {
-        if (!manager.enabled)
-            return;
-        const pad = e.gamepad;
-        const prev = getOrCreateGamepadPollState(manager);
-        prev.axes.delete(pad.index);
-        prev.buttons.delete(pad.index);
-        _connectData.gamepad = pad.index;
-        _connectData.id = pad.id;
-        _connectData.mapping = pad.mapping === 'standard' ? 'standard' : pad.mapping === '' ? '' : 'raw';
-        emitSignal(manager.onGamepadDisconnect, _connectData);
-    };
-    let rafId = 0;
-    const loop = () => {
-        pollGamepadInput(manager);
-        rafId = requestAnimationFrame(loop);
-    };
-    target.addEventListener('gamepadconnected', onGamepadConnected);
-    target.addEventListener('gamepaddisconnected', onGamepadDisconnected);
-    rafId = requestAnimationFrame(loop);
-    setInputBinding(manager, target, kGamepadInput, () => {
-        target.removeEventListener('gamepadconnected', onGamepadConnected);
-        target.removeEventListener('gamepaddisconnected', onGamepadDisconnected);
-        cancelAnimationFrame(rafId);
-    });
-    // Suppress unused-options warning; options accepted for API symmetry.
-    void options;
+export function attachGamepadInput(manager, source, options) {
+    const release = getInputIngressBackend().attachGamepad(source, getInputIngressSink(manager), options);
+    setInputBinding(manager, source, kGamepadInput, release);
 }
-export function attachKeyboardInput(manager, target, options) {
-    const preventDefault = options?.preventDefault ?? true;
-    const onKeyDown = (e) => {
-        if (!manager.enabled)
-            return;
-        const ke = e;
-        if (preventDefault)
-            ke.preventDefault();
-        setInputKeyboardData(_keyboardData, ke);
-        emitSignal(manager.onKeyDown, _keyboardData);
-    };
-    const onKeyUp = (e) => {
-        if (!manager.enabled)
-            return;
-        const ke = e;
-        if (preventDefault)
-            ke.preventDefault();
-        setInputKeyboardData(_keyboardData, ke);
-        emitSignal(manager.onKeyUp, _keyboardData);
-    };
-    target.addEventListener('keydown', onKeyDown);
-    target.addEventListener('keyup', onKeyUp);
-    setInputBinding(manager, target, kKeyboardInput, () => {
-        target.removeEventListener('keydown', onKeyDown);
-        target.removeEventListener('keyup', onKeyUp);
-    });
+export function attachKeyboardInput(manager, source, options) {
+    const release = getInputIngressBackend().attachKeyboard(source, getInputIngressSink(manager), options);
+    setInputBinding(manager, source, kKeyboardInput, release);
 }
-export function attachPointerInput(manager, element, options) {
-    const preventDefault = options?.preventDefault ?? true;
-    const onContextMenu = (e) => {
-        if (preventDefault)
-            e.preventDefault();
-    };
-    const onPointerCancel = (e) => {
-        if (!manager.enabled)
-            return;
-        if (preventDefault)
-            e.preventDefault();
-        setInputPointerData(_pointerData, e, 0, 0);
-        emitSignal(manager.onPointerCancel, _pointerData);
-    };
-    const onPointerDown = (e) => {
-        if (!manager.enabled)
-            return;
-        if (preventDefault)
-            e.preventDefault();
-        setInputPointerData(_pointerData, e, 0, 0);
-        emitSignal(manager.onPointerDown, _pointerData);
-    };
-    const onPointerMove = (e) => {
-        if (!manager.enabled)
-            return;
-        if (preventDefault)
-            e.preventDefault();
-        setInputPointerData(_pointerData, e, 0, 0);
-        emitSignal(manager.onPointerMove, _pointerData);
-    };
-    const onPointerUp = (e) => {
-        if (!manager.enabled)
-            return;
-        if (preventDefault)
-            e.preventDefault();
-        setInputPointerData(_pointerData, e, 0, 0);
-        emitSignal(manager.onPointerUp, _pointerData);
-    };
-    element.addEventListener('contextmenu', onContextMenu);
-    element.addEventListener('pointercancel', onPointerCancel);
-    element.addEventListener('pointerdown', onPointerDown);
-    element.addEventListener('pointermove', onPointerMove);
-    element.addEventListener('pointerup', onPointerUp);
-    setInputBinding(manager, element, kPointerInput, () => {
-        element.removeEventListener('contextmenu', onContextMenu);
-        element.removeEventListener('pointercancel', onPointerCancel);
-        element.removeEventListener('pointerdown', onPointerDown);
-        element.removeEventListener('pointermove', onPointerMove);
-        element.removeEventListener('pointerup', onPointerUp);
-    });
+export function attachPointerInput(manager, source, options) {
+    const release = getInputIngressBackend().attachPointer(source, getInputIngressSink(manager), options);
+    setInputBinding(manager, source, kPointerInput, release);
 }
-export function attachRelativePointerInput(manager, element, options) {
-    const preventDefault = options?.preventDefault ?? true;
-    const target = element.ownerDocument;
-    const handler = (e) => {
-        if (!manager.enabled)
-            return;
-        const me = e;
-        if (preventDefault)
-            me.preventDefault();
-        setInputPointerData(_pointerData, me, me.movementX, me.movementY);
-        emitSignal(manager.onPointerMoveRelative, _pointerData);
-    };
-    target.addEventListener('mousemove', handler);
-    setInputBinding(manager, element, kRelativePointerInput, () => target.removeEventListener('mousemove', handler));
+export function attachRelativePointerInput(manager, source, options) {
+    const release = getInputIngressBackend().attachRelativePointer(source, getInputIngressSink(manager), options);
+    setInputBinding(manager, source, kRelativePointerInput, release);
 }
-export function attachTextInput(manager, element, options) {
-    const onBeforeInput = (e) => {
-        if (!manager.enabled)
-            return;
-        const ie = e;
-        const text = ie.data ?? '';
-        _textData.isComposing = ie.isComposing;
-        _textData.text = text;
-        emitSignal(manager.onTextInput, _textData);
-    };
-    const onCompositionUpdate = (e) => {
-        if (!manager.enabled)
-            return;
-        const ce = e;
-        const text = ce.data ?? '';
-        _textData.isComposing = true;
-        _textData.text = text;
-        emitSignal(manager.onTextEdit, _textData);
-    };
-    element.addEventListener('beforeinput', onBeforeInput);
-    element.addEventListener('compositionupdate', onCompositionUpdate);
-    setInputBinding(manager, element, kTextInput, () => {
-        element.removeEventListener('beforeinput', onBeforeInput);
-        element.removeEventListener('compositionupdate', onCompositionUpdate);
-    });
-    // Suppress unused-options warning; options accepted for API symmetry.
-    void options;
+export function attachTextInput(manager, source, options) {
+    const release = getInputIngressBackend().attachText(source, getInputIngressSink(manager), options);
+    setInputBinding(manager, source, kTextInput, release);
 }
-export function attachWheelInput(manager, element, options) {
-    const preventDefault = options?.preventDefault ?? true;
-    const handler = (e) => {
-        if (!manager.enabled)
-            return;
-        const we = e;
-        if (preventDefault)
-            we.preventDefault();
-        setInputPointerData(_pointerData, we, we.deltaX, we.deltaY);
-        _pointerData.wheelMode = getMouseWheelModeFromDomWheelEvent(we);
-        emitSignal(manager.onWheel, _pointerData);
-    };
-    element.addEventListener('wheel', handler, { passive: !preventDefault });
-    setInputBinding(manager, element, kWheelInput, () => element.removeEventListener('wheel', handler));
+export function attachWheelInput(manager, source, options) {
+    const release = getInputIngressBackend().attachWheel(source, getInputIngressSink(manager), options);
+    setInputBinding(manager, source, kWheelInput, release);
 }
 /**
  * Subscribes `state` to all signals on `manager` to maintain a live held-state snapshot.
@@ -268,10 +115,9 @@ export function connectInputStateToInputManager(state, manager) {
     const onPointerCancel = (data) => {
         state.pointerButtonsDown.delete(data.pointerId);
     };
-    // Same transition rules as the keyboard pair above. pollGamepadInput already edge-detects before it
-    // emits, so it cannot produce a repeat itself — but these signals are public and a native backend
-    // reporting held buttons each poll is a supported source, so the guard belongs on the state machine
-    // rather than in one producer.
+    // Same transition rules as the keyboard pair above. The Web adapter edge-detects before it emits,
+    // but these signals are public and a native backend reporting held buttons each poll is a supported
+    // source, so the guard belongs on the state machine rather than in one producer.
     const onGamepadButtonDown = (data) => {
         const key = data.gamepad * MAX_GAMEPAD_BUTTONS + data.button;
         if (!state.gamepadButtonsDown.has(key))
@@ -414,23 +260,261 @@ export function createInputState() {
         pointerButtonsDown: new Map(),
     };
 }
-export function detachGamepadInput(manager, target) {
-    clearInputBinding(manager, target, kGamepadInput);
+/** Explicit browser adapter for the process-wide input-ingress seam. */
+export function createWebInputIngressBackend() {
+    return {
+        attachGamepad(source, sink) {
+            const target = getWebInputEventTarget(source);
+            if (target === null)
+                return noopInputIngressRelease;
+            const previousAxes = new Map();
+            const previousButtons = new Map();
+            let released = false;
+            let frameHandle = 0;
+            const onGamepadConnected = (event) => {
+                if (released || !sink.isEnabled())
+                    return;
+                const gamepad = event.gamepad;
+                previousAxes.set(gamepad.index, Array.from(gamepad.axes));
+                previousButtons.set(gamepad.index, Array.from(gamepad.buttons, (button) => button.pressed));
+                setInputGamepadConnectData(_connectData, gamepad);
+                sink.gamepadConnect(_connectData);
+            };
+            const onGamepadDisconnected = (event) => {
+                if (released || !sink.isEnabled())
+                    return;
+                const gamepad = event.gamepad;
+                previousAxes.delete(gamepad.index);
+                previousButtons.delete(gamepad.index);
+                setInputGamepadConnectData(_connectData, gamepad);
+                sink.gamepadDisconnect(_connectData);
+            };
+            const poll = () => {
+                if (!sink.isEnabled() || typeof navigator.getGamepads !== 'function')
+                    return;
+                const now = performance.now();
+                for (const gamepad of navigator.getGamepads()) {
+                    if (gamepad === null)
+                        continue;
+                    const axes = previousAxes.get(gamepad.index) ?? [];
+                    const buttons = previousButtons.get(gamepad.index) ?? [];
+                    for (let index = 0; index < gamepad.axes.length; index++) {
+                        const value = gamepad.axes[index];
+                        if (value === axes[index])
+                            continue;
+                        axes[index] = value;
+                        _axisData.axis = index;
+                        _axisData.gamepad = gamepad.index;
+                        _axisData.timeStamp = now;
+                        _axisData.value = value;
+                        sink.gamepadAxisMove(_axisData);
+                        if (released)
+                            return;
+                    }
+                    for (let index = 0; index < gamepad.buttons.length; index++) {
+                        const button = gamepad.buttons[index];
+                        const wasPressed = buttons[index] ?? false;
+                        if (button.pressed === wasPressed)
+                            continue;
+                        buttons[index] = button.pressed;
+                        _buttonData.button = index;
+                        _buttonData.gamepad = gamepad.index;
+                        _buttonData.timeStamp = now;
+                        _buttonData.value = button.value;
+                        if (button.pressed)
+                            sink.gamepadButtonDown(_buttonData);
+                        else
+                            sink.gamepadButtonUp(_buttonData);
+                        if (released)
+                            return;
+                    }
+                    previousAxes.set(gamepad.index, axes);
+                    previousButtons.set(gamepad.index, buttons);
+                }
+            };
+            const loop = () => {
+                if (released)
+                    return;
+                // Schedule first so a signal handler that detaches reentrantly cancels the only future frame.
+                frameHandle = requestAnimationFrame(loop);
+                poll();
+            };
+            target.addEventListener('gamepadconnected', onGamepadConnected);
+            target.addEventListener('gamepaddisconnected', onGamepadDisconnected);
+            frameHandle = requestAnimationFrame(loop);
+            return () => {
+                if (released)
+                    return;
+                released = true;
+                target.removeEventListener('gamepadconnected', onGamepadConnected);
+                target.removeEventListener('gamepaddisconnected', onGamepadDisconnected);
+                cancelAnimationFrame(frameHandle);
+            };
+        },
+        attachKeyboard(source, sink, options) {
+            const target = getWebInputEventTarget(source);
+            if (target === null)
+                return noopInputIngressRelease;
+            const preventDefault = options?.preventDefault ?? true;
+            const onKeyDown = (event) => {
+                if (!sink.isEnabled())
+                    return;
+                const keyboardEvent = event;
+                if (preventDefault)
+                    keyboardEvent.preventDefault();
+                setInputKeyboardData(_keyboardData, keyboardEvent);
+                sink.keyDown(_keyboardData);
+            };
+            const onKeyUp = (event) => {
+                if (!sink.isEnabled())
+                    return;
+                const keyboardEvent = event;
+                if (preventDefault)
+                    keyboardEvent.preventDefault();
+                setInputKeyboardData(_keyboardData, keyboardEvent);
+                sink.keyUp(_keyboardData);
+            };
+            target.addEventListener('keydown', onKeyDown);
+            target.addEventListener('keyup', onKeyUp);
+            return () => {
+                target.removeEventListener('keydown', onKeyDown);
+                target.removeEventListener('keyup', onKeyUp);
+            };
+        },
+        attachPointer(source, sink, options) {
+            const target = getWebInputEventTarget(source);
+            if (target === null)
+                return noopInputIngressRelease;
+            const preventDefault = options?.preventDefault ?? true;
+            const onContextMenu = (event) => {
+                if (preventDefault)
+                    event.preventDefault();
+            };
+            const onPointerCancel = (event) => {
+                if (!sink.isEnabled())
+                    return;
+                if (preventDefault)
+                    event.preventDefault();
+                setInputPointerData(_pointerData, event, 0, 0);
+                sink.pointerCancel(_pointerData);
+            };
+            const onPointerDown = (event) => {
+                if (!sink.isEnabled())
+                    return;
+                if (preventDefault)
+                    event.preventDefault();
+                setInputPointerData(_pointerData, event, 0, 0);
+                sink.pointerDown(_pointerData);
+            };
+            const onPointerMove = (event) => {
+                if (!sink.isEnabled())
+                    return;
+                if (preventDefault)
+                    event.preventDefault();
+                setInputPointerData(_pointerData, event, 0, 0);
+                sink.pointerMove(_pointerData);
+            };
+            const onPointerUp = (event) => {
+                if (!sink.isEnabled())
+                    return;
+                if (preventDefault)
+                    event.preventDefault();
+                setInputPointerData(_pointerData, event, 0, 0);
+                sink.pointerUp(_pointerData);
+            };
+            target.addEventListener('contextmenu', onContextMenu);
+            target.addEventListener('pointercancel', onPointerCancel);
+            target.addEventListener('pointerdown', onPointerDown);
+            target.addEventListener('pointermove', onPointerMove);
+            target.addEventListener('pointerup', onPointerUp);
+            return () => {
+                target.removeEventListener('contextmenu', onContextMenu);
+                target.removeEventListener('pointercancel', onPointerCancel);
+                target.removeEventListener('pointerdown', onPointerDown);
+                target.removeEventListener('pointermove', onPointerMove);
+                target.removeEventListener('pointerup', onPointerUp);
+            };
+        },
+        attachRelativePointer(source, sink, options) {
+            const target = getWebInputOwnerDocumentTarget(source);
+            if (target === null)
+                return noopInputIngressRelease;
+            const preventDefault = options?.preventDefault ?? true;
+            const onMouseMove = (event) => {
+                if (!sink.isEnabled())
+                    return;
+                const mouseEvent = event;
+                if (preventDefault)
+                    mouseEvent.preventDefault();
+                setInputPointerData(_pointerData, mouseEvent, mouseEvent.movementX, mouseEvent.movementY);
+                sink.pointerMoveRelative(_pointerData);
+            };
+            target.addEventListener('mousemove', onMouseMove);
+            return () => target.removeEventListener('mousemove', onMouseMove);
+        },
+        attachText(source, sink) {
+            const target = getWebInputEventTarget(source);
+            if (target === null)
+                return noopInputIngressRelease;
+            const onBeforeInput = (event) => {
+                if (!sink.isEnabled())
+                    return;
+                const inputEvent = event;
+                _textData.isComposing = inputEvent.isComposing;
+                _textData.text = inputEvent.data ?? '';
+                sink.textInput(_textData);
+            };
+            const onCompositionUpdate = (event) => {
+                if (!sink.isEnabled())
+                    return;
+                _textData.isComposing = true;
+                _textData.text = event.data ?? '';
+                sink.textEdit(_textData);
+            };
+            target.addEventListener('beforeinput', onBeforeInput);
+            target.addEventListener('compositionupdate', onCompositionUpdate);
+            return () => {
+                target.removeEventListener('beforeinput', onBeforeInput);
+                target.removeEventListener('compositionupdate', onCompositionUpdate);
+            };
+        },
+        attachWheel(source, sink, options) {
+            const target = getWebInputEventTarget(source);
+            if (target === null)
+                return noopInputIngressRelease;
+            const preventDefault = options?.preventDefault ?? true;
+            const onWheel = (event) => {
+                if (!sink.isEnabled())
+                    return;
+                const wheelEvent = event;
+                if (preventDefault)
+                    wheelEvent.preventDefault();
+                setInputPointerData(_pointerData, wheelEvent, wheelEvent.deltaX, wheelEvent.deltaY);
+                _pointerData.wheelMode = getMouseWheelModeFromDomWheelEvent(wheelEvent);
+                sink.wheel(_pointerData);
+            };
+            target.addEventListener('wheel', onWheel, { passive: !preventDefault });
+            return () => target.removeEventListener('wheel', onWheel);
+        },
+    };
+}
+export function detachGamepadInput(manager, source) {
+    clearInputBinding(manager, source, kGamepadInput);
 }
-export function detachKeyboardInput(manager, target) {
-    clearInputBinding(manager, target, kKeyboardInput);
+export function detachKeyboardInput(manager, source) {
+    clearInputBinding(manager, source, kKeyboardInput);
 }
-export function detachPointerInput(manager, element) {
-    clearInputBinding(manager, element, kPointerInput);
+export function detachPointerInput(manager, source) {
+    clearInputBinding(manager, source, kPointerInput);
 }
-export function detachRelativePointerInput(manager, element) {
-    clearInputBinding(manager, element, kRelativePointerInput);
+export function detachRelativePointerInput(manager, source) {
+    clearInputBinding(manager, source, kRelativePointerInput);
 }
-export function detachTextInput(manager, element) {
-    clearInputBinding(manager, element, kTextInput);
+export function detachTextInput(manager, source) {
+    clearInputBinding(manager, source, kTextInput);
 }
-export function detachWheelInput(manager, element) {
-    clearInputBinding(manager, element, kWheelInput);
+export function detachWheelInput(manager, source) {
+    clearInputBinding(manager, source, kWheelInput);
 }
 /**
  * Rolls the per-frame edge sets on `state`, clearing `justPressedKeys`,
@@ -444,15 +528,6 @@ export function endInputStateFrame(state) {
     state.justPressedGamepadButtons.clear();
     state.justReleasedGamepadButtons.clear();
 }
-/**
- * Exits pointer lock, returning the pointer to normal movement.
- * No-op if pointer lock is not currently active.
- */
-export function exitInputPointerLock() {
-    if (document.exitPointerLock) {
-        document.exitPointerLock();
-    }
-}
 /**
  * Returns coalesced pointer event data for a `pointermove` event, iterating
  * over the high-frequency intermediate positions captured since the last
@@ -502,6 +577,9 @@ export function getGamepadButtonName(mapping, index) {
 export function getInputGamepadAxis(state, gamepad, axis) {
     return state.axisValues.get(gamepad * MAX_GAMEPAD_AXES + axis) ?? 0;
 }
+export function getInputIngressBackend() {
+    return _customInputIngressBackend ?? _hostInputIngressBackend ?? _webInputIngressBackend;
+}
 export function getKeyCodeFromDomKeyboardEvent(event) {
     const code = getKeyCodeFromDomKeyboardCode(event.code, event.location);
     if (code !== KeyCode.UNKNOWN)
@@ -538,11 +616,10 @@ export function getMouseWheelModeFromDomWheelEvent(event) {
         return 'pages';
     return 'unknown';
 }
-/**
- * Returns `true` if pointer lock is currently active on any element.
- */
-export function hasInputPointerLock() {
-    return document.pointerLockElement !== null;
+// First host wins; a custom backend installed through setInputIngressBackend always takes precedence.
+export function installInputIngressHostBackend(backend) {
+    if (_hostInputIngressBackend === null)
+        _hostInputIngressBackend = backend;
 }
 /**
  * Returns `true` if the given gamepad button is currently held.
@@ -564,49 +641,6 @@ export function isInputKeyDown(state, keyCode) {
 export function isInputPointerButtonDown(state, pointerId, button) {
     return ((state.pointerButtonsDown.get(pointerId) ?? 0) & (1 << button)) !== 0;
 }
-export function pollGamepadInput(manager) {
-    if (!manager.enabled || typeof navigator.getGamepads !== 'function')
-        return;
-    const now = performance.now();
-    const prev = getOrCreateGamepadPollState(manager);
-    const gamepads = navigator.getGamepads();
-    for (const pad of gamepads) {
-        if (pad === null)
-            continue;
-        const prevAxes = prev.axes.get(pad.index) ?? [];
-        const prevButtons = prev.buttons.get(pad.index) ?? [];
-        for (let i = 0; i < pad.axes.length; i++) {
-            const value = pad.axes[i];
-            if (value !== prevAxes[i]) {
-                prevAxes[i] = value;
-                _axisData.axis = i;
-                _axisData.gamepad = pad.index;
-                _axisData.timeStamp = now;
-                _axisData.value = value;
-                emitSignal(manager.onGamepadAxisMove, _axisData);
-            }
-        }
-        for (let i = 0; i < pad.buttons.length; i++) {
-            const btn = pad.buttons[i];
-            const wasPressed = prevButtons[i] ?? false;
-            if (btn.pressed !== wasPressed) {
-                prevButtons[i] = btn.pressed;
-                _buttonData.button = i;
-                _buttonData.gamepad = pad.index;
-                _buttonData.timeStamp = now;
-                _buttonData.value = btn.value;
-                if (btn.pressed) {
-                    emitSignal(manager.onGamepadButtonDown, _buttonData);
-                }
-                else {
-                    emitSignal(manager.onGamepadButtonUp, _buttonData);
-                }
-            }
-        }
-        prev.axes.set(pad.index, prevAxes);
-        prev.buttons.set(pad.index, prevButtons);
-    }
-}
 /**
  * Releases pointer capture for `pointerId` from `element`, allowing pointer
  * events to fire on the element under the pointer again.
@@ -620,22 +654,12 @@ export function releaseInputPointerCapture(element, pointerId) {
         // Ignore — the pointer may have already been released.
     }
 }
-/**
- * Requests pointer lock on `element`. Returns a `Promise<boolean>` that
- * resolves to `true` when lock is granted or `false` if the request is
- * rejected (e.g. outside a user gesture, or the browser denies it).
- */
-export function requestInputPointerLock(element) {
-    try {
-        const result = element.requestPointerLock();
-        if (result instanceof Promise) {
-            return result.then(() => true, () => false);
-        }
-        return Promise.resolve(true);
-    }
-    catch {
-        return Promise.resolve(false);
-    }
+export function resetInputIngressBackendForTest() {
+    _customInputIngressBackend = null;
+    _hostInputIngressBackend = null;
+}
+export function setInputIngressBackend(backend) {
+    _customInputIngressBackend = backend;
 }
 /**
  * Explicitly captures all pointer events for `pointerId` to `element`,
@@ -995,22 +1019,107 @@ const _textData = {
     isComposing: false,
     text: '',
 };
-const _gamepadPollStates = new WeakMap();
-function getOrCreateGamepadPollState(manager) {
-    let state = _gamepadPollStates.get(manager);
-    if (state === undefined) {
-        state = { axes: new Map(), buttons: new Map() };
-        _gamepadPollStates.set(manager, state);
-    }
-    return state;
-}
 const _axisData = { axis: 0, gamepad: 0, timeStamp: 0, value: 0 };
 const _buttonData = { button: 0, gamepad: 0, timeStamp: 0, value: 0 };
 const _connectData = { gamepad: 0, id: '', mapping: '' };
-// Internal teardown registry: maps a manager to its per-target, per-input-kind cleanup closures.
-// Kept off the public InputManager entity (a side table like `_gamepadPollStates`) so attach/detach
-// track bindings internally and callers hold nothing. The nested EventTarget key lets one manager
-// attach the same input kind to multiple elements and detach each precisely.
+const _inputIngressSinks = new WeakMap();
+function getInputIngressSink(manager) {
+    let sink = _inputIngressSinks.get(manager);
+    if (sink !== undefined)
+        return sink;
+    sink = {
+        gamepadAxisMove(data) {
+            if (manager.enabled)
+                emitSignal(manager.onGamepadAxisMove, data);
+        },
+        gamepadButtonDown(data) {
+            if (manager.enabled)
+                emitSignal(manager.onGamepadButtonDown, data);
+        },
+        gamepadButtonUp(data) {
+            if (manager.enabled)
+                emitSignal(manager.onGamepadButtonUp, data);
+        },
+        gamepadConnect(data) {
+            if (manager.enabled)
+                emitSignal(manager.onGamepadConnect, data);
+        },
+        gamepadDisconnect(data) {
+            if (manager.enabled)
+                emitSignal(manager.onGamepadDisconnect, data);
+        },
+        isEnabled() {
+            return manager.enabled;
+        },
+        keyDown(data) {
+            if (manager.enabled)
+                emitSignal(manager.onKeyDown, data);
+        },
+        keyUp(data) {
+            if (manager.enabled)
+                emitSignal(manager.onKeyUp, data);
+        },
+        pointerCancel(data) {
+            if (manager.enabled)
+                emitSignal(manager.onPointerCancel, data);
+        },
+        pointerDown(data) {
+            if (manager.enabled)
+                emitSignal(manager.onPointerDown, data);
+        },
+        pointerMove(data) {
+            if (manager.enabled)
+                emitSignal(manager.onPointerMove, data);
+        },
+        pointerMoveRelative(data) {
+            if (manager.enabled)
+                emitSignal(manager.onPointerMoveRelative, data);
+        },
+        pointerUp(data) {
+            if (manager.enabled)
+                emitSignal(manager.onPointerUp, data);
+        },
+        textEdit(data) {
+            if (manager.enabled)
+                emitSignal(manager.onTextEdit, data);
+        },
+        textInput(data) {
+            if (manager.enabled)
+                emitSignal(manager.onTextInput, data);
+        },
+        wheel(data) {
+            if (manager.enabled)
+                emitSignal(manager.onWheel, data);
+        },
+    };
+    _inputIngressSinks.set(manager, sink);
+    return sink;
+}
+function getWebInputEventTarget(source) {
+    const candidate = source;
+    return typeof candidate.addEventListener === 'function' && typeof candidate.removeEventListener === 'function'
+        ? candidate
+        : null;
+}
+function getWebInputOwnerDocumentTarget(source) {
+    if (!('ownerDocument' in source))
+        return null;
+    const ownerDocument = source.ownerDocument;
+    return ownerDocument === undefined || ownerDocument === null ? null : getWebInputEventTarget(ownerDocument);
+}
+function noopInputIngressRelease() { }
+function setInputGamepadConnectData(out, gamepad) {
+    out.gamepad = gamepad.index;
+    out.id = gamepad.id;
+    out.mapping = gamepad.mapping === 'standard' ? 'standard' : gamepad.mapping === '' ? '' : 'raw';
+}
+const _webInputIngressBackend = createWebInputIngressBackend();
+let _customInputIngressBackend = null;
+let _hostInputIngressBackend = null;
+// Internal teardown registry: maps a manager to its per-source, per-input-kind origin release.
+// Kept off the public InputManager entity so attach/detach track bindings internally and callers hold
+// nothing. The exact source identity lets one manager attach the same input kind to multiple
+// windows/sources and detach each precisely.
 const kGamepadInput = Symbol();
 const kKeyboardInput = Symbol();
 const kPointerInput = Symbol();
@@ -1018,26 +1127,33 @@ const kRelativePointerInput = Symbol();
 const kTextInput = Symbol();
 const kWheelInput = Symbol();
 const _inputBindings = new WeakMap();
-function clearInputBinding(manager, target, kind) {
-    const byKind = _inputBindings.get(manager)?.get(target);
-    const cleanup = byKind?.get(kind);
-    if (cleanup === undefined)
+function clearInputBinding(manager, source, kind) {
+    const bySource = _inputBindings.get(manager);
+    const byKind = bySource?.get(source);
+    const release = byKind?.get(kind);
+    if (release === undefined)
         return;
-    cleanup();
     byKind.delete(kind);
+    if (byKind.size === 0)
+        bySource.delete(source);
+    release();
 }
-function setInputBinding(manager, target, kind, cleanup) {
-    let byTarget = _inputBindings.get(manager);
-    if (byTarget === undefined) {
-        byTarget = new Map();
-        _inputBindings.set(manager, byTarget);
+function setInputBinding(manager, source, kind, release) {
+    let bySource = _inputBindings.get(manager);
+    if (bySource === undefined) {
+        bySource = new Map();
+        _inputBindings.set(manager, bySource);
     }
-    let byKind = byTarget.get(target);
+    let byKind = bySource.get(source);
     if (byKind === undefined) {
         byKind = new Map();
-        byTarget.set(target, byKind);
+        bySource.set(source, byKind);
+    }
+    const previous = byKind.get(kind);
+    if (previous !== undefined) {
+        byKind.delete(kind);
+        previous();
     }
-    byKind.get(kind)?.();
-    byKind.set(kind, cleanup);
+    byKind.set(kind, release);
 }
 //# sourceMappingURL=inputManager.js.map