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

package/src/inputManager.test.ts

@@ -1,5 +1,11 @@
 import { connectSignal, emitSignal } from '@flighthq/signals/contract';
-import type { InputGamepadButtonData, InputPointerData } from '@flighthq/types/contract';
+import type {
+  InputGamepadButtonData,
+  InputIngressBackend,
+  InputIngressSink,
+  InputIngressSource,
+  InputPointerData,
+} from '@flighthq/types/contract';
 import { GamepadAxisKind, GamepadButtonKind, KeyCode, KeyModifier } from '@flighthq/types/contract';
 
 import {
@@ -16,6 +22,7 @@ import {
   createInputManager,
   createInputSignals,
   createInputState,
+  createWebInputIngressBackend,
   detachGamepadInput,
   detachKeyboardInput,
   detachPointerInput,
@@ -23,21 +30,21 @@ import {
   detachTextInput,
   detachWheelInput,
   endInputStateFrame,
-  exitInputPointerLock,
   getCoalescedInputPointerEvents,
   getGamepadAxisName,
   getGamepadButtonName,
   getInputGamepadAxis,
+  getInputIngressBackend,
   getKeyCodeFromDomKeyboardEvent,
   getKeyModifierFromDomKeyboardEvent,
   getMouseWheelModeFromDomWheelEvent,
-  hasInputPointerLock,
   isInputGamepadButtonDown,
   isInputKeyDown,
   isInputPointerButtonDown,
-  pollGamepadInput,
+  installInputIngressHostBackend,
   releaseInputPointerCapture,
-  requestInputPointerLock,
+  resetInputIngressBackendForTest,
+  setInputIngressBackend,
   setInputPointerCapture,
   wasInputGamepadButtonPressed,
   wasInputGamepadButtonReleased,
@@ -45,6 +52,27 @@ import {
   wasInputKeyReleased,
 } from './inputManager';
 
+afterEach(() => {
+  resetInputIngressBackendForTest();
+  vi.unstubAllGlobals();
+});
+
+type InputIngressAttachmentKind = 'gamepad' | 'keyboard' | 'pointer' | 'relativePointer' | 'text' | 'wheel';
+
+function createTestInputIngressBackend(
+  attach: (kind: InputIngressAttachmentKind, source: InputIngressSource, sink: InputIngressSink) => () => void = () =>
+    () => {},
+): InputIngressBackend {
+  return {
+    attachGamepad: (source, sink) => attach('gamepad', source, sink),
+    attachKeyboard: (source, sink) => attach('keyboard', source, sink),
+    attachPointer: (source, sink) => attach('pointer', source, sink),
+    attachRelativePointer: (source, sink) => attach('relativePointer', source, sink),
+    attachText: (source, sink) => attach('text', source, sink),
+    attachWheel: (source, sink) => attach('wheel', source, sink),
+  };
+}
+
 describe('applyGamepadAxisDeadZone', () => {
   it('returns 0 when value is within the dead zone', () => {
     expect(applyGamepadAxisDeadZone(0.1, 0.2)).toBe(0);
@@ -141,6 +169,42 @@ describe('attachGamepadInput', () => {
     window.dispatchEvent(createGamepadEvent('gamepadconnected', 0, 'Pad'));
     expect(fired).toBe(0);
   });
+
+  it('accepts native axis and button pushes without browser polling globals', () => {
+    let sink: InputIngressSink | null = null;
+    setInputIngressBackend(
+      createTestInputIngressBackend((kind, _source, attachedSink) => {
+        if (kind === 'gamepad') sink = attachedSink;
+        return () => {};
+      }),
+    );
+    vi.stubGlobal('navigator', undefined);
+    vi.stubGlobal('requestAnimationFrame', undefined);
+    vi.stubGlobal('cancelAnimationFrame', undefined);
+    vi.stubGlobal('performance', undefined);
+    const manager = createInputManager();
+    const state = createInputState();
+    connectInputStateToInputManager(state, manager);
+    const events: string[] = [];
+    connectSignal(manager.onGamepadConnect, () => events.push('connect'));
+    connectSignal(manager.onGamepadAxisMove, () => events.push('axis'));
+    connectSignal(manager.onGamepadButtonDown, () => events.push('down'));
+    connectSignal(manager.onGamepadButtonUp, () => events.push('up'));
+    connectSignal(manager.onGamepadDisconnect, () => events.push('disconnect'));
+
+    attachGamepadInput(manager, {});
+    sink!.gamepadConnect({ gamepad: 2, id: 'Native Pad', mapping: 'raw' });
+    sink!.gamepadAxisMove({ axis: 1, gamepad: 2, timeStamp: 10, value: 0.75 });
+    sink!.gamepadButtonDown({ button: 3, gamepad: 2, timeStamp: 11, value: 1 });
+    expect(getInputGamepadAxis(state, 2, 1)).toBe(0.75);
+    expect(isInputGamepadButtonDown(state, 2, 3)).toBe(true);
+    sink!.gamepadButtonUp({ button: 3, gamepad: 2, timeStamp: 12, value: 0 });
+    sink!.gamepadDisconnect({ gamepad: 2, id: 'Native Pad', mapping: 'raw' });
+
+    expect(events).toEqual(['connect', 'axis', 'down', 'up', 'disconnect']);
+    expect(getInputGamepadAxis(state, 2, 1)).toBe(0);
+    expect(isInputGamepadButtonDown(state, 2, 3)).toBe(false);
+  });
 });
 
 describe('attachKeyboardInput', () => {
@@ -414,24 +478,9 @@ describe('connectInputStateToInputManager', () => {
     const state = createInputState();
     connectInputStateToInputManager(state, manager);
 
-    const mockPad = {
-      axes: [],
-      buttons: [{ pressed: true, value: 1, touched: true }],
-      index: 0,
-    } as unknown as Gamepad;
-    vi.spyOn(navigator, 'getGamepads').mockReturnValue([mockPad, null, null, null]);
-
-    pollGamepadInput(manager);
+    emitSignal(manager.onGamepadButtonDown, { button: 0, gamepad: 0, timeStamp: 1, value: 1 });
     expect(isInputGamepadButtonDown(state, 0, 0)).toBe(true);
-
-    const mockPadReleased = {
-      axes: [],
-      buttons: [{ pressed: false, value: 0, touched: false }],
-      index: 0,
-    } as unknown as Gamepad;
-    vi.spyOn(navigator, 'getGamepads').mockReturnValue([mockPadReleased, null, null, null]);
-
-    pollGamepadInput(manager);
+    emitSignal(manager.onGamepadButtonUp, { button: 0, gamepad: 0, timeStamp: 2, value: 0 });
     expect(isInputGamepadButtonDown(state, 0, 0)).toBe(false);
   });
 
@@ -440,14 +489,7 @@ describe('connectInputStateToInputManager', () => {
     const state = createInputState();
     connectInputStateToInputManager(state, manager);
 
-    const mockPad = {
-      axes: [0.75],
-      buttons: [],
-      index: 0,
-    } as unknown as Gamepad;
-    vi.spyOn(navigator, 'getGamepads').mockReturnValue([mockPad, null, null, null]);
-
-    pollGamepadInput(manager);
+    emitSignal(manager.onGamepadAxisMove, { axis: 0, gamepad: 0, timeStamp: 1, value: 0.75 });
     expect(getInputGamepadAxis(state, 0, 0)).toBe(0.75);
   });
 
@@ -574,6 +616,159 @@ describe('createInputState', () => {
   });
 });
 
+describe('createWebInputIngressBackend', () => {
+  it('owns gamepad polling and emits only changed Web state', () => {
+    const frames = installManualAnimationFrames();
+    const getGamepads = vi.fn<() => Gamepad[]>();
+    Object.defineProperty(navigator, 'getGamepads', { configurable: true, value: getGamepads });
+    const manager = createInputManager();
+    const axes: number[] = [];
+    const buttons: number[] = [];
+    connectSignal(manager.onGamepadAxisMove, (data) => axes.push(data.value));
+    connectSignal(manager.onGamepadButtonUp, (data) => buttons.push(data.value));
+    attachGamepadInput(manager, window);
+
+    const initial = createGamepad(0, 'Pad', [0.25], [{ pressed: true, touched: true, value: 1 }]);
+    getGamepads.mockReturnValue([initial]);
+    window.dispatchEvent(createGamepadEvent('gamepadconnected', initial));
+    frames.runAllCurrent();
+    expect(axes).toEqual([]);
+    expect(buttons).toEqual([]);
+
+    getGamepads.mockReturnValue([createGamepad(0, 'Pad', [0.75], [{ pressed: false, touched: false, value: 0 }])]);
+    frames.runAllCurrent();
+    expect(axes).toEqual([0.75]);
+    expect(buttons).toEqual([0]);
+    frames.runAllCurrent();
+    expect(axes).toEqual([0.75]);
+    expect(buttons).toEqual([0]);
+    detachGamepadInput(manager, window);
+  });
+
+  it('keeps Web polling state and releases independent per source', () => {
+    const frames = installManualAnimationFrames();
+    const getGamepads = vi.fn<() => Gamepad[]>().mockReturnValue([createGamepad(0, 'Pad', [0.5], [])]);
+    Object.defineProperty(navigator, 'getGamepads', { configurable: true, value: getGamepads });
+    const firstSource = new EventTarget();
+    const secondSource = new EventTarget();
+    const firstManager = createInputManager();
+    const secondManager = createInputManager();
+    let firstMoves = 0;
+    let secondMoves = 0;
+    connectSignal(firstManager.onGamepadAxisMove, () => firstMoves++);
+    connectSignal(secondManager.onGamepadAxisMove, () => secondMoves++);
+    attachGamepadInput(firstManager, firstSource);
+    attachGamepadInput(secondManager, secondSource);
+
+    frames.runAllCurrent();
+    expect([firstMoves, secondMoves]).toEqual([1, 1]);
+    detachGamepadInput(firstManager, firstSource);
+    getGamepads.mockReturnValue([createGamepad(0, 'Pad', [0.75], [])]);
+    frames.runAllCurrent();
+    expect([firstMoves, secondMoves]).toEqual([1, 2]);
+    detachGamepadInput(secondManager, secondSource);
+    expect(frames.pending.size).toBe(0);
+  });
+
+  it('routes two window identities only to their corresponding managers', () => {
+    const firstFrame = document.createElement('iframe');
+    const secondFrame = document.createElement('iframe');
+    document.body.append(firstFrame, secondFrame);
+    const firstWindow = firstFrame.contentWindow!;
+    const secondWindow = secondFrame.contentWindow!;
+    const firstManager = createInputManager();
+    const secondManager = createInputManager();
+    const firstEvents: number[] = [];
+    const secondEvents: number[] = [];
+    connectSignal(firstManager.onKeyDown, (data) => firstEvents.push(data.keyCode));
+    connectSignal(secondManager.onKeyDown, (data) => secondEvents.push(data.keyCode));
+    attachKeyboardInput(firstManager, firstWindow);
+    attachKeyboardInput(secondManager, secondWindow);
+
+    firstWindow.dispatchEvent(createKeyboardEvent('keydown', { code: 'KeyA', key: 'a' }));
+    expect(firstEvents).toEqual([KeyCode.A]);
+    expect(secondEvents).toEqual([]);
+
+    secondWindow.dispatchEvent(createKeyboardEvent('keydown', { code: 'KeyB', key: 'b' }));
+    expect(firstEvents).toEqual([KeyCode.A]);
+    expect(secondEvents).toEqual([KeyCode.B]);
+
+    detachKeyboardInput(firstManager, firstWindow);
+    detachKeyboardInput(secondManager, secondWindow);
+    firstFrame.remove();
+    secondFrame.remove();
+  });
+
+  it('returns inert releases for native source identities the Web adapter cannot interpret', () => {
+    const frames = installManualAnimationFrames();
+    const backend = createWebInputIngressBackend();
+    const source = {};
+    const sink = {} as InputIngressSink;
+    expect(() => backend.attachKeyboard(source, sink)()).not.toThrow();
+    expect(() => backend.attachGamepad(source, sink)()).not.toThrow();
+    expect(frames.request).not.toHaveBeenCalled();
+  });
+});
+
+describe('createWebInputIngressBackend gamepad polling', () => {
+  beforeEach(() => {
+    Object.defineProperty(navigator, 'getGamepads', {
+      configurable: true,
+      value: () => [],
+    });
+  });
+
+  it('emits onGamepadButtonDown when a button transitions to pressed', () => {
+    const frames = installManualAnimationFrames();
+    const manager = createInputManager();
+    const mockPad = { axes: [], buttons: [{ pressed: true, touched: true, value: 1 }], index: 0 } as unknown as Gamepad;
+    vi.spyOn(navigator, 'getGamepads').mockReturnValue([mockPad, null, null, null]);
+
+    let received: { button: number; gamepad: number } | null = null;
+    connectSignal(manager.onGamepadButtonDown, (data: Readonly<InputGamepadButtonData>) => {
+      received = { button: data.button, gamepad: data.gamepad };
+    });
+
+    attachGamepadInput(manager, window);
+    frames.runAllCurrent();
+    expect(received).toEqual({ button: 0, gamepad: 0 });
+    detachGamepadInput(manager, window);
+  });
+
+  it('populates timeStamp on gamepad button data', () => {
+    const frames = installManualAnimationFrames();
+    const manager = createInputManager();
+    const mockPad = { axes: [], buttons: [{ pressed: true, touched: true, value: 1 }], index: 0 } as unknown as Gamepad;
+    vi.spyOn(navigator, 'getGamepads').mockReturnValue([mockPad, null, null, null]);
+
+    let receivedTimeStamp = -1;
+    connectSignal(manager.onGamepadButtonDown, (data: Readonly<InputGamepadButtonData>) => {
+      receivedTimeStamp = data.timeStamp;
+    });
+
+    attachGamepadInput(manager, window);
+    frames.runAllCurrent();
+    expect(receivedTimeStamp).toBeGreaterThanOrEqual(0);
+    detachGamepadInput(manager, window);
+  });
+
+  it('does not emit when state is unchanged', () => {
+    const frames = installManualAnimationFrames();
+    const manager = createInputManager();
+    const mockPad = { axes: [], buttons: [{ pressed: true, touched: true, value: 1 }], index: 0 } as unknown as Gamepad;
+    vi.spyOn(navigator, 'getGamepads').mockReturnValue([mockPad, null, null, null]);
+
+    attachGamepadInput(manager, window);
+    frames.runAllCurrent();
+
+    let fired = 0;
+    connectSignal(manager.onGamepadButtonDown, () => fired++);
+    frames.runAllCurrent();
+    expect(fired).toBe(0);
+    detachGamepadInput(manager, window);
+  });
+});
+
 describe('detachGamepadInput', () => {
   it('removes listeners so signals stop firing', () => {
     const manager = createInputManager();
@@ -591,6 +786,21 @@ describe('detachGamepadInput', () => {
     const manager = createInputManager();
     expect(() => detachGamepadInput(manager, window)).not.toThrow();
   });
+
+  it('cannot resurrect Web polling when detached from a sink callback', () => {
+    const frames = installManualAnimationFrames();
+    Object.defineProperty(navigator, 'getGamepads', {
+      configurable: true,
+      value: () => [createGamepad(0, 'Pad', [0.5], [])],
+    });
+    const manager = createInputManager();
+    connectSignal(manager.onGamepadAxisMove, () => detachGamepadInput(manager, window));
+    attachGamepadInput(manager, window);
+
+    frames.runAllCurrent();
+    expect(frames.pending.size).toBe(0);
+    expect(frames.cancel).toHaveBeenCalledOnce();
+  });
 });
 
 describe('detachKeyboardInput', () => {
@@ -717,20 +927,6 @@ describe('endInputStateFrame', () => {
   });
 });
 
-describe('exitInputPointerLock', () => {
-  it('calls document.exitPointerLock when available', () => {
-    let called = false;
-    Object.defineProperty(document, 'exitPointerLock', {
-      configurable: true,
-      value: () => {
-        called = true;
-      },
-    });
-    exitInputPointerLock();
-    expect(called).toBe(true);
-  });
-});
-
 describe('getCoalescedInputPointerEvents', () => {
   it('falls back to a single event when getCoalescedEvents is unavailable', () => {
     const event = createPointerEvent('pointermove', { clientX: 10, clientY: 20 });
@@ -800,6 +996,13 @@ describe('getInputGamepadAxis', () => {
   });
 });
 
+describe('getInputIngressBackend', () => {
+  it('uses one stable Web fallback', () => {
+    const fallback = getInputIngressBackend();
+    expect(getInputIngressBackend()).toBe(fallback);
+  });
+});
+
 describe('getKeyCodeFromDomKeyboardEvent', () => {
   it('maps printable keys to SDL-compatible lower-case codes', () => {
     expect(getKeyCodeFromDomKeyboardEvent(createKeyboardEvent('keydown', { key: 'A' }))).toBe(KeyCode.A);
@@ -875,27 +1078,12 @@ describe('getMouseWheelModeFromDomWheelEvent', () => {
   });
 });
 
-describe('hasInputPointerLock', () => {
-  it('returns false when no element is pointer-locked', () => {
-    Object.defineProperty(document, 'pointerLockElement', {
-      configurable: true,
-      get: () => null,
-    });
-    expect(hasInputPointerLock()).toBe(false);
-  });
-
-  it('returns true when an element holds the pointer lock', () => {
-    const element = document.createElement('div');
-    Object.defineProperty(document, 'pointerLockElement', {
-      configurable: true,
-      get: () => element,
-    });
-    expect(hasInputPointerLock()).toBe(true);
-    // Restore
-    Object.defineProperty(document, 'pointerLockElement', {
-      configurable: true,
-      get: () => null,
-    });
+describe('installInputIngressHostBackend', () => {
+  it('preserves the first installed host identity', () => {
+    const firstHost = createTestInputIngressBackend();
+    installInputIngressHostBackend(firstHost);
+    installInputIngressHostBackend(createTestInputIngressBackend());
+    expect(getInputIngressBackend()).toBe(firstHost);
   });
 });
 
@@ -920,56 +1108,6 @@ describe('isInputPointerButtonDown', () => {
   });
 });
 
-describe('pollGamepadInput', () => {
-  beforeEach(() => {
-    Object.defineProperty(navigator, 'getGamepads', {
-      configurable: true,
-      value: () => [],
-    });
-  });
-
-  it('emits onGamepadButtonDown when a button transitions to pressed', () => {
-    const manager = createInputManager();
-    const mockPad = { axes: [], buttons: [{ pressed: true, touched: true, value: 1 }], index: 0 } as unknown as Gamepad;
-    vi.spyOn(navigator, 'getGamepads').mockReturnValue([mockPad, null, null, null]);
-
-    let received: { button: number; gamepad: number } | null = null;
-    connectSignal(manager.onGamepadButtonDown, (data: Readonly<InputGamepadButtonData>) => {
-      received = { button: data.button, gamepad: data.gamepad };
-    });
-
-    pollGamepadInput(manager);
-    expect(received).toEqual({ button: 0, gamepad: 0 });
-  });
-
-  it('populates timeStamp on gamepad button data', () => {
-    const manager = createInputManager();
-    const mockPad = { axes: [], buttons: [{ pressed: true, touched: true, value: 1 }], index: 0 } as unknown as Gamepad;
-    vi.spyOn(navigator, 'getGamepads').mockReturnValue([mockPad, null, null, null]);
-
-    let receivedTimeStamp = -1;
-    connectSignal(manager.onGamepadButtonDown, (data: Readonly<InputGamepadButtonData>) => {
-      receivedTimeStamp = data.timeStamp;
-    });
-
-    pollGamepadInput(manager);
-    expect(receivedTimeStamp).toBeGreaterThanOrEqual(0);
-  });
-
-  it('does not emit when state is unchanged', () => {
-    const manager = createInputManager();
-    const mockPad = { axes: [], buttons: [{ pressed: true, touched: true, value: 1 }], index: 0 } as unknown as Gamepad;
-    vi.spyOn(navigator, 'getGamepads').mockReturnValue([mockPad, null, null, null]);
-
-    pollGamepadInput(manager);
-
-    let fired = 0;
-    connectSignal(manager.onGamepadButtonDown, () => fired++);
-    pollGamepadInput(manager);
-    expect(fired).toBe(0);
-  });
-});
-
 describe('releaseInputPointerCapture', () => {
   it('calls releasePointerCapture on the element', () => {
     const element = document.createElement('div');
@@ -990,30 +1128,116 @@ describe('releaseInputPointerCapture', () => {
   });
 });
 
-describe('requestInputPointerLock', () => {
-  it('resolves to true when requestPointerLock succeeds synchronously', async () => {
-    const element = document.createElement('div');
-    // Cast: synchronous void return is valid per the spec (older browsers), but the
-    // TypeScript lib types it as Promise<void>; the double cast handles the overlap check.
-    element.requestPointerLock = (() => undefined) as unknown as () => Promise<void>;
-    const result = await requestInputPointerLock(element);
-    expect(result).toBe(true);
+describe('resetInputIngressBackendForTest', () => {
+  it('clears custom and host slots back to the Web fallback', () => {
+    const fallback = getInputIngressBackend();
+    installInputIngressHostBackend(createTestInputIngressBackend());
+    setInputIngressBackend(createTestInputIngressBackend());
+
+    resetInputIngressBackendForTest();
+    expect(getInputIngressBackend()).toBe(fallback);
   });
+});
 
-  it('resolves to true when requestPointerLock returns a resolving Promise', async () => {
-    const element = document.createElement('div');
-    element.requestPointerLock = () => Promise.resolve();
-    const result = await requestInputPointerLock(element);
-    expect(result).toBe(true);
+describe('setInputIngressBackend', () => {
+  it('gives a custom backend precedence and reveals the installed host when cleared', () => {
+    const firstHost = createTestInputIngressBackend();
+    installInputIngressHostBackend(firstHost);
+    const custom = createTestInputIngressBackend();
+    setInputIngressBackend(custom);
+    expect(getInputIngressBackend()).toBe(custom);
+    setInputIngressBackend(null);
+    expect(getInputIngressBackend()).toBe(firstHost);
+  });
+
+  it('passes each exact source identity through all six attachment families and releases each once', () => {
+    const attachments: Array<Readonly<{ kind: InputIngressAttachmentKind; source: InputIngressSource }>> = [];
+    const releases = new Map<InputIngressAttachmentKind, ReturnType<typeof vi.fn>>();
+    setInputIngressBackend(
+      createTestInputIngressBackend((kind, source) => {
+        attachments.push({ kind, source });
+        const release = vi.fn();
+        releases.set(kind, release);
+        return release;
+      }),
+    );
+    const manager = createInputManager();
+    const sources = {
+      gamepad: {},
+      keyboard: {},
+      pointer: {},
+      relativePointer: {},
+      text: {},
+      wheel: {},
+    } satisfies Record<InputIngressAttachmentKind, InputIngressSource>;
+
+    attachGamepadInput(manager, sources.gamepad);
+    attachKeyboardInput(manager, sources.keyboard);
+    attachPointerInput(manager, sources.pointer);
+    attachRelativePointerInput(manager, sources.relativePointer);
+    attachTextInput(manager, sources.text);
+    attachWheelInput(manager, sources.wheel);
+
+    expect(attachments).toEqual([
+      { kind: 'gamepad', source: sources.gamepad },
+      { kind: 'keyboard', source: sources.keyboard },
+      { kind: 'pointer', source: sources.pointer },
+      { kind: 'relativePointer', source: sources.relativePointer },
+      { kind: 'text', source: sources.text },
+      { kind: 'wheel', source: sources.wheel },
+    ]);
+
+    detachGamepadInput(manager, sources.gamepad);
+    detachKeyboardInput(manager, sources.keyboard);
+    detachPointerInput(manager, sources.pointer);
+    detachRelativePointerInput(manager, sources.relativePointer);
+    detachTextInput(manager, sources.text);
+    detachWheelInput(manager, sources.wheel);
+    detachGamepadInput(manager, sources.gamepad);
+    detachKeyboardInput(manager, sources.keyboard);
+    detachPointerInput(manager, sources.pointer);
+    detachRelativePointerInput(manager, sources.relativePointer);
+    detachTextInput(manager, sources.text);
+    detachWheelInput(manager, sources.wheel);
+
+    expect([...releases.values()].every((release) => release.mock.calls.length === 1)).toBe(true);
+  });
+
+  it('pins cleanup to the originating backend and never destroys the borrowed source', () => {
+    const releaseA = vi.fn();
+    const releaseB = vi.fn();
+    const backendA = createTestInputIngressBackend((kind) => (kind === 'keyboard' ? releaseA : vi.fn()));
+    const backendB = createTestInputIngressBackend((kind) => (kind === 'keyboard' ? releaseB : vi.fn()));
+    const source = { destroy: vi.fn() };
+    const manager = createInputManager();
+
+    setInputIngressBackend(backendA);
+    attachKeyboardInput(manager, source);
+    setInputIngressBackend(backendB);
+    detachKeyboardInput(manager, source);
+    detachKeyboardInput(manager, source);
+
+    expect(releaseA).toHaveBeenCalledOnce();
+    expect(releaseB).not.toHaveBeenCalled();
+    expect(source.destroy).not.toHaveBeenCalled();
   });
 
-  it('resolves to false when requestPointerLock throws', async () => {
-    const element = document.createElement('div');
-    element.requestPointerLock = () => {
-      throw new Error('Not allowed');
-    };
-    const result = await requestInputPointerLock(element);
-    expect(result).toBe(false);
+  it('releases the old origin once when the same source is reattached after backend replacement', () => {
+    const releaseA = vi.fn();
+    const releaseB = vi.fn();
+    const source = {};
+    const manager = createInputManager();
+
+    setInputIngressBackend(createTestInputIngressBackend(() => releaseA));
+    attachPointerInput(manager, source);
+    setInputIngressBackend(createTestInputIngressBackend(() => releaseB));
+    attachPointerInput(manager, source);
+    expect(releaseA).toHaveBeenCalledOnce();
+
+    detachPointerInput(manager, source);
+    detachPointerInput(manager, source);
+    expect(releaseA).toHaveBeenCalledOnce();
+    expect(releaseB).toHaveBeenCalledOnce();
   });
 });
 
@@ -1042,9 +1266,7 @@ describe('wasInputGamepadButtonPressed', () => {
     const state = createInputState();
     connectInputStateToInputManager(state, manager);
 
-    const mockPad = { axes: [], buttons: [{ pressed: true, touched: true, value: 1 }], index: 0 } as unknown as Gamepad;
-    vi.spyOn(navigator, 'getGamepads').mockReturnValue([mockPad, null, null, null]);
-    pollGamepadInput(manager);
+    emitSignal(manager.onGamepadButtonDown, { button: 0, gamepad: 0, timeStamp: 1, value: 1 });
 
     expect(wasInputGamepadButtonPressed(state, 0, 0)).toBe(true);
   });
@@ -1054,17 +1276,15 @@ describe('wasInputGamepadButtonPressed', () => {
     const state = createInputState();
     connectInputStateToInputManager(state, manager);
 
-    const mockPad = { axes: [], buttons: [{ pressed: true, touched: true, value: 1 }], index: 0 } as unknown as Gamepad;
-    vi.spyOn(navigator, 'getGamepads').mockReturnValue([mockPad, null, null, null]);
-    pollGamepadInput(manager);
+    emitSignal(manager.onGamepadButtonDown, { button: 0, gamepad: 0, timeStamp: 1, value: 1 });
     endInputStateFrame(state);
 
     expect(wasInputGamepadButtonPressed(state, 0, 0)).toBe(false);
   });
 
-  // Driven by emitting the signal rather than by pollGamepadInput, because the built-in poller already
-  // edge-detects and so cannot produce a repeat. A native backend reporting held buttons every poll
-  // can, and these signals are public — which is why the guard belongs on the state machine.
+  // Driven by emitting the signal because the Web adapter already edge-detects and cannot produce a
+  // repeat. A native backend reporting held buttons every poll can, and these signals are public —
+  // which is why the guard belongs on the state machine.
   it('returns false when a held button is reported down again', () => {
     const manager = createInputManager();
     const state = createInputState();
@@ -1108,24 +1328,12 @@ describe('wasInputGamepadButtonReleased', () => {
     const state = createInputState();
     connectInputStateToInputManager(state, manager);
 
-    // Press the button first
-    const mockPadDown = {
-      axes: [],
-      buttons: [{ pressed: true, touched: true, value: 1 }],
-      index: 0,
-    } as unknown as Gamepad;
-    vi.spyOn(navigator, 'getGamepads').mockReturnValue([mockPadDown, null, null, null]);
-    pollGamepadInput(manager);
+    // Press the button first.
+    emitSignal(manager.onGamepadButtonDown, { button: 0, gamepad: 0, timeStamp: 1, value: 1 });
     endInputStateFrame(state);
 
-    // Release it
-    const mockPadUp = {
-      axes: [],
-      buttons: [{ pressed: false, touched: false, value: 0 }],
-      index: 0,
-    } as unknown as Gamepad;
-    vi.spyOn(navigator, 'getGamepads').mockReturnValue([mockPadUp, null, null, null]);
-    pollGamepadInput(manager);
+    // Release it.
+    emitSignal(manager.onGamepadButtonUp, { button: 0, gamepad: 0, timeStamp: 2, value: 0 });
 
     expect(wasInputGamepadButtonReleased(state, 0, 0)).toBe(true);
   });
@@ -1299,17 +1507,58 @@ function createWheelEvent(options: WheelEventInit = {}): WheelEvent {
   });
 }
 
-function createGamepadEvent(type: string, index: number, id: string): Event {
-  const event = new Event(type, { bubbles: false }) as GamepadEvent;
-  const gamepad = {
-    axes: [],
-    buttons: [],
+function createGamepad(
+  index: number,
+  id: string,
+  axes: readonly number[] = [],
+  buttons: readonly GamepadButton[] = [],
+): Gamepad {
+  return {
+    axes,
+    buttons,
     connected: true,
     id,
     index,
     mapping: 'standard',
     timestamp: 0,
   } as unknown as Gamepad;
+}
+
+function createGamepadEvent(type: string, gamepadOrIndex: Gamepad | number, id?: string): Event {
+  const event = new Event(type, { bubbles: false }) as GamepadEvent;
+  const gamepad = typeof gamepadOrIndex === 'number' ? createGamepad(gamepadOrIndex, id ?? '') : gamepadOrIndex;
   Object.defineProperty(event, 'gamepad', { value: gamepad });
   return event;
 }
+
+function installManualAnimationFrames(): Readonly<{
+  cancel: ReturnType<typeof vi.fn>;
+  pending: Map<number, FrameRequestCallback>;
+  request: ReturnType<typeof vi.fn>;
+  runAllCurrent(): void;
+}> {
+  let nextHandle = 1;
+  const pending = new Map<number, FrameRequestCallback>();
+  const request = vi.fn((callback: FrameRequestCallback): number => {
+    const handle = nextHandle++;
+    pending.set(handle, callback);
+    return handle;
+  });
+  const cancel = vi.fn((handle: number): void => {
+    pending.delete(handle);
+  });
+  vi.stubGlobal('requestAnimationFrame', request);
+  vi.stubGlobal('cancelAnimationFrame', cancel);
+  return {
+    cancel,
+    pending,
+    request,
+    runAllCurrent(): void {
+      const current = [...pending.entries()];
+      for (const [handle, callback] of current) {
+        if (!pending.delete(handle)) continue;
+        callback(performance.now());
+      }
+    },
+  };
+}