PlayerInput

import { runMechanicContract } from '@babylonjsmarket/ecs/testing';
import {
  PlayerInputComponent,
  PlayerInputSystem,
  PlayerInputInputEvents,
} from './PlayerInput';

runMechanicContract({
  name: 'PlayerInput',
  componentClass: PlayerInputComponent,
  systemClass: PlayerInputSystem,
  sampleInput: { gamepadIndex: 2 },
  // Only SET_ENABLED is a pure-EventBus input; ACTION_PRESSED / MOVE_CHANGED
  // are driven by DOM keyboard + Gamepad API traffic that the contract battery
  // can't synthesize reliably. Mechanic-specific tests in PlayerInput.test.ts
  // cover those output paths.
  events: {
    input: [PlayerInputInputEvents.SET_ENABLED],
  },
  makeInputPayload(event) {
    if (event === PlayerInputInputEvents.SET_ENABLED) return { enabled: true };
    return {};
  },
});

import { describe, it, expect } from 'vitest';
import { createPlayerInput, DEFAULT_PLAYER_INPUT_PARAMS } from './PlayerInput.core';

describe('PlayerInput core', () => {
  it('a pressed key activates its bound action', () => {
    const input = createPlayerInput();
    input.pressKey('Space');
    expect(input.isActive('jump')).toBe(true);
  });

  it('justPressed fires once, then empties on the next consume', () => {
    const input = createPlayerInput();
    input.pressKey('Space');
    const first = input.consume();
    expect(first.justPressed).toContain('jump');
    const second = input.consume();
    expect(second.justPressed).toHaveLength(0);
  });

  it('releasing a key deactivates the action and queues justReleased', () => {
    const input = createPlayerInput();
    input.pressKey('KeyE');
    input.consume();
    input.releaseKey('KeyE');
    const s = input.consume();
    expect(s.justReleased).toContain('attack');
    expect(input.isActive('attack')).toBe(false);
  });

  it('multiple keys bound to the same action only release when the last one lifts', () => {
    const input = createPlayerInput();
    input.pressKey('KeyW');
    input.pressKey('ArrowUp');
    input.releaseKey('KeyW');
    expect(input.isActive('moveForward')).toBe(true);
    input.releaseKey('ArrowUp');
    expect(input.isActive('moveForward')).toBe(false);
  });

  it('forward + right produces a diagonal move vector normalised to unit length', () => {
    const input = createPlayerInput();
    input.pressKey('KeyW');
    input.pressKey('KeyD');
    const s = input.consume();
    expect(Math.hypot(s.moveX, s.moveZ)).toBeCloseTo(1, 5);
    expect(s.moveX).toBeGreaterThan(0);
    expect(s.moveZ).toBeGreaterThan(0);
  });

  it('gamepad axis below the deadzone is treated as zero', () => {
    const input = createPlayerInput({ deadzone: 0.2 });
    input.setGamepadAxis(0, 0.1);
    expect(input.consume().moveX).toBe(0);
    input.setGamepadAxis(0, 0.5);
    expect(input.consume().moveX).toBe(0.5);
  });

  it('gamepad button triggers the same action as its bound key', () => {
    const input = createPlayerInput();
    input.pressGamepadButton(0);
    expect(input.isActive('jump')).toBe(true);
    const s = input.consume();
    expect(s.source).toBe('gamepad');
  });

  it('a repeated gamepad button press is a no-op (returns null)', () => {
    const input = createPlayerInput();
    expect(input.pressGamepadButton(0)).toBe('jump');
    expect(input.pressGamepadButton(0)).toBeNull();
  });

  it('releasing a gamepad button deactivates its action and queues justReleased', () => {
    const input = createPlayerInput();
    input.pressGamepadButton(2); // attack
    input.consume();
    expect(input.releaseGamepadButton(2)).toBe('attack');
    const s = input.consume();
    expect(s.justReleased).toContain('attack');
    expect(input.isActive('attack')).toBe(false);
  });

  it('releasing a gamepad button that was never pressed returns null', () => {
    const input = createPlayerInput();
    expect(input.releaseGamepadButton(3)).toBeNull();
  });

  it('the vertical gamepad axis drives forward/back with Y inverted', () => {
    const input = createPlayerInput({ deadzone: 0.1 });
    // Push the stick "up" (negative Y); forward is +Z, so moveZ goes positive.
    input.setGamepadAxis(1, -0.6);
    expect(input.consume().moveZ).toBeCloseTo(0.6, 5);
    // A vertical value inside the deadzone reads as zero.
    input.setGamepadAxis(1, 0.05);
    expect(input.consume().moveZ).toBe(0);
  });

  it('reset clears all active actions and zeroes the move vector', () => {
    const input = createPlayerInput();
    input.pressKey('KeyW');
    input.pressGamepadButton(2);
    input.reset();
    const s = input.consume();
    expect(s.active.size).toBe(0);
    expect(s.moveX).toBe(0);
    expect(s.moveZ).toBe(0);
  });

  it('setParams.keyBindings rebinds on the fly without dropping held state', () => {
    const input = createPlayerInput();
    input.pressKey('KeyQ');
    expect(input.isActive('attack')).toBe(false);
    input.setParams({ keyBindings: { attack: ['KeyQ'] } });
    expect(input.isActive('attack')).toBe(true);
  });

  it('getParams reflects the defaults when none are provided', () => {
    const input = createPlayerInput();
    expect(input.getParams().deadzone).toBe(DEFAULT_PLAYER_INPUT_PARAMS.deadzone);
  });
});

// @vitest-environment jsdom
import { describe, it, expect, vi, afterEach } from 'vitest';
import { render, fireEvent } from '@solidjs/testing-library';
import { PlayerInputPanel } from './PlayerInput.panel';
import { createPlayerInput, DEFAULT_PLAYER_INPUT_PARAMS } from './PlayerInput.core';

describe('PlayerInputPanel', () => {
  it('mounts without a renderer and shows the active-actions section', () => {
    const core = createPlayerInput();
    const { container } = render(() => <PlayerInputPanel core={core} />);
    expect(container.textContent).toContain('Active actions');
    expect(container.textContent).toContain('Move vector');
    expect(container.textContent).toContain('deadzone');
  });

  it('moving the deadzone slider pushes the new value into the core', () => {
    const core = createPlayerInput();
    const spy = vi.spyOn(core, 'setParams');
    const { getAllByRole } = render(() => <PlayerInputPanel core={core} />);
    const slider = (getAllByRole('slider') as HTMLInputElement[])[0];
    fireEvent.input(slider, { target: { value: '0.3' } });
    expect(spy).toHaveBeenCalledWith(expect.objectContaining({ deadzone: 0.3 }));
  });

  it('renders the default key bindings in a readable row per action', () => {
    const core = createPlayerInput();
    const { container } = render(() => <PlayerInputPanel core={core} />);
    expect(container.textContent).toContain('jump');
    expect(container.textContent).toContain('Space');
    expect(container.textContent).toContain('KeyW');
  });

  it('the Reset button restores defaults on the core', () => {
    const core = createPlayerInput({ deadzone: 0.4 });
    const { getByText } = render(() => <PlayerInputPanel core={core} />);
    fireEvent.click(getByText(/Reset/i));
    // Reset pushes deadzone + both binding tables back to the defaults.
    expect(core.getParams().deadzone).toBe(DEFAULT_PLAYER_INPUT_PARAMS.deadzone);
  });

  describe('polling tap', () => {
    afterEach(() => {
      vi.useRealTimers();
    });

    it('surfaces active actions, move vector and source from the core each tick', () => {
      vi.useFakeTimers();
      const core = createPlayerInput();
      core.pressKey('KeyW'); // moveForward, keyboard source
      core.pressKey('KeyD'); // moveRight → diagonal
      const { container } = render(() => <PlayerInputPanel core={core} />);

      // Before the first poll the readout is still empty.
      expect(container.textContent).toContain('(press a mapped key)');

      vi.advanceTimersByTime(120);

      // The For block now lists both active actions, sorted.
      expect(container.textContent).toContain('moveForward');
      expect(container.textContent).toContain('moveRight');
      // Move vector readout reflects a unit diagonal, source is keyboard.
      expect(container.textContent).toContain('0.71');
      expect(container.textContent).toContain('keyboard');
    });

    it('reflects an external deadzone/binding change pushed onto the core', () => {
      vi.useFakeTimers();
      const core = createPlayerInput();
      const { getAllByRole, container } = render(() => <PlayerInputPanel core={core} />);
      const slider = (getAllByRole('slider') as HTMLInputElement[])[0];
      expect(slider.value).toBe('0.15');

      // Something other than the panel rebinds + retunes the core.
      core.setParams({ deadzone: 0.42, keyBindings: { dash: ['ShiftLeft'] } });
      vi.advanceTimersByTime(120);

      expect(slider.value).toBe('0.42');
      expect(container.textContent).toContain('dash');
    });

    it('renders a gamepad source colour once a stick drives the core', () => {
      vi.useFakeTimers();
      const core = createPlayerInput();
      core.setGamepadAxis(0, 0.9);
      const { container } = render(() => <PlayerInputPanel core={core} />);

      vi.advanceTimersByTime(120);
      expect(container.textContent).toContain('gamepad');
    });
  });
});

import { describe, it, expect, beforeEach, vi, afterEach } from 'vitest';
import {
  PlayerInputComponent,
  PlayerInputSystem,
  PlayerInputEvents,
  PlayerInputInputEvents,
} from './PlayerInput';
import { EventBus, World } from '@babylonjsmarket/ecs';
import { MockRendererAdapter } from '@babylonjsmarket/ecs';

describe('PlayerInputComponent', () => {
  it('applies defaults', () => {
    const comp = new PlayerInputComponent();
    expect(comp.enabled).toBe(true);
    expect(comp.gamepadIndex).toBe(0);
    expect(comp.params.deadzone).toBe(0.15);
    expect(comp.params.keyBindings.jump).toContain('Space');
  });

  it('merges custom key bindings on top of defaults', () => {
    const comp = new PlayerInputComponent({
      keyBindings: { attack: ['KeyQ'] },
    });
    expect(comp.params.keyBindings.attack).toEqual(['KeyQ']);
    expect(comp.params.keyBindings.jump).toContain('Space');
  });

  it('serialize round-trips', () => {
    const original = new PlayerInputComponent({ deadzone: 0.3, gamepadIndex: 1 });
    const copy = new PlayerInputComponent(original.serialize());
    expect(copy.params.deadzone).toBe(0.3);
    expect(copy.gamepadIndex).toBe(1);
  });
});

describe('PlayerInputSystem', () => {
  let eventBus: EventBus;
  let world: World;
  let renderer: MockRendererAdapter;
  let system: PlayerInputSystem;

  beforeEach(() => {
    eventBus = new EventBus();
    renderer = new MockRendererAdapter();
    world = new World({ eventBus, renderer });
    system = new PlayerInputSystem(eventBus);
    world.addSystem(system);
    world.initialize();
  });

  afterEach(() => {
    world.destroy();
  });

  it('creates a core instance on entity add', () => {
    const entity = world.createEntity();
    const comp = new PlayerInputComponent();
    entity.add(comp);
    expect(comp.instance).not.toBeNull();
  });

  it('a keydown emits ACTION_PRESSED for the bound action', () => {
    const entity = world.createEntity('player');
    entity.add(new PlayerInputComponent());
    const spy = vi.fn();
    eventBus.on(PlayerInputEvents.ACTION_PRESSED, spy);
    window.dispatchEvent(new KeyboardEvent('keydown', { code: 'Space' }));
    world.update(1 / 60);
    const jumpCall = spy.mock.calls.find((c) => c[0].action === 'jump');
    expect(jumpCall).toBeDefined();
    expect(jumpCall![0].entityId).toBe(entity.id);
  });

  it('WASD drives MOVE_CHANGED with a normalised vector', () => {
    const entity = world.createEntity('player');
    entity.add(new PlayerInputComponent());
    const moves: Array<{ x: number; z: number }> = [];
    eventBus.on(PlayerInputEvents.MOVE_CHANGED, (e) => moves.push(e));
    window.dispatchEvent(new KeyboardEvent('keydown', { code: 'KeyW' }));
    window.dispatchEvent(new KeyboardEvent('keydown', { code: 'KeyD' }));
    world.update(1 / 60);
    const last = moves[moves.length - 1];
    expect(Math.hypot(last.x, last.z)).toBeCloseTo(1, 5);
  });

  it('SET_ENABLED false stops emitting actions', () => {
    const entity = world.createEntity('player');
    entity.add(new PlayerInputComponent());
    eventBus.emit(PlayerInputInputEvents.SET_ENABLED, { enabled: false });
    const spy = vi.fn();
    eventBus.on(PlayerInputEvents.ACTION_PRESSED, spy);
    window.dispatchEvent(new KeyboardEvent('keydown', { code: 'KeyE' }));
    world.update(1 / 60);
    expect(spy).not.toHaveBeenCalled();
    void entity;
  });

  it('releasing all keys bound to an action emits ACTION_RELEASED once', () => {
    const entity = world.createEntity('player');
    entity.add(new PlayerInputComponent());
    const released = vi.fn();
    eventBus.on(PlayerInputEvents.ACTION_RELEASED, released);
    window.dispatchEvent(new KeyboardEvent('keydown', { code: 'KeyW' }));
    world.update(1 / 60);
    window.dispatchEvent(new KeyboardEvent('keyup', { code: 'KeyW' }));
    world.update(1 / 60);
    const fwdRelease = released.mock.calls.find((c) => c[0].action === 'moveForward');
    expect(fwdRelease).toBeDefined();
    void entity;
  });

  it('is non-pauseable', () => {
    expect((system as unknown as { _pauseable: boolean })._pauseable).toBe(false);
  });
});

describe('PlayerInputSystem gamepad polling', () => {
  let eventBus: EventBus;
  let world: World;
  let renderer: MockRendererAdapter;

  // Minimal Gamepad-shaped object the poll loop reads: buttons[].pressed + axes[].
  type FakePad = { buttons: Array<{ pressed: boolean }>; axes: number[] } | null;
  let pad: FakePad;

  beforeEach(() => {
    eventBus = new EventBus();
    renderer = new MockRendererAdapter();
    world = new World({ eventBus, renderer });
    world.addSystem(new PlayerInputSystem(eventBus));
    world.initialize();
    pad = null;
    vi.stubGlobal('navigator', {
      getGamepads: () => [pad] as unknown as (Gamepad | null)[],
    });
  });

  afterEach(() => {
    vi.unstubAllGlobals();
    world.destroy();
  });

  it('a freshly-pressed gamepad button emits ACTION_PRESSED', () => {
    world.createEntity('player').add(new PlayerInputComponent());
    const spy = vi.fn();
    eventBus.on(PlayerInputEvents.ACTION_PRESSED, spy);

    pad = { buttons: [{ pressed: true }], axes: [0, 0] }; // button 0 = jump
    world.update(1 / 60);

    const jump = spy.mock.calls.find((c) => c[0].action === 'jump');
    expect(jump).toBeDefined();
    expect(jump![0].source).toBe('gamepad');
  });

  it('a held button does not re-fire, and releasing it emits ACTION_RELEASED', () => {
    world.createEntity('player').add(new PlayerInputComponent());
    const pressed = vi.fn();
    const released = vi.fn();
    eventBus.on(PlayerInputEvents.ACTION_PRESSED, pressed);
    eventBus.on(PlayerInputEvents.ACTION_RELEASED, released);

    pad = { buttons: [{ pressed: true }], axes: [0, 0] };
    world.update(1 / 60);
    const pressCount = pressed.mock.calls.filter((c) => c[0].action === 'jump').length;

    // Same snapshot again → no new press.
    world.update(1 / 60);
    expect(pressed.mock.calls.filter((c) => c[0].action === 'jump').length).toBe(pressCount);

    // Button up → release fires.
    pad = { buttons: [{ pressed: false }], axes: [0, 0] };
    world.update(1 / 60);
    expect(released.mock.calls.find((c) => c[0].action === 'jump')).toBeDefined();
  });

  it('moving a stick past the deadzone emits MOVE_CHANGED only when the axis changes', () => {
    world.createEntity('player').add(new PlayerInputComponent());
    const moves: Array<{ x: number; z: number }> = [];
    eventBus.on(PlayerInputEvents.MOVE_CHANGED, (e) => moves.push(e));

    pad = { buttons: [], axes: [0.8, 0] };
    world.update(1 / 60);
    expect(moves[moves.length - 1].x).toBeCloseTo(0.8, 5);

    // Identical axis next frame → no extra MOVE_CHANGED.
    const countAfterFirst = moves.length;
    world.update(1 / 60);
    expect(moves.length).toBe(countAfterFirst);

    // A new vertical reading flows through (axes index 1 → moveZ branch).
    pad = { buttons: [], axes: [0.8, -0.5] };
    world.update(1 / 60);
    expect(moves[moves.length - 1].z).toBeCloseTo(0.5, 5);
  });

  it('skips entities whose gamepad slot is empty', () => {
    world.createEntity('player').add(new PlayerInputComponent({ gamepadIndex: 0 }));
    const spy = vi.fn();
    eventBus.on(PlayerInputEvents.ACTION_PRESSED, spy);

    pad = null; // slot 0 has no pad
    world.update(1 / 60);
    expect(spy).not.toHaveBeenCalled();
  });

  it('ignores gamepads for a disabled component', () => {
    world.createEntity('player').add(new PlayerInputComponent({ enabled: false }));
    const spy = vi.fn();
    eventBus.on(PlayerInputEvents.ACTION_PRESSED, spy);

    pad = { buttons: [{ pressed: true }], axes: [0, 0] };
    world.update(1 / 60);
    expect(spy).not.toHaveBeenCalled();
  });
});

describe('PlayerInputSystem without a Gamepad API', () => {
  it('poll is a no-op when navigator.getGamepads is unavailable', () => {
    const eventBus = new EventBus();
    const renderer = new MockRendererAdapter();
    const world = new World({ eventBus, renderer });
    world.addSystem(new PlayerInputSystem(eventBus));
    world.initialize();
    world.createEntity('player').add(new PlayerInputComponent());

    vi.stubGlobal('navigator', {});
    const spy = vi.fn();
    eventBus.on(PlayerInputEvents.ACTION_PRESSED, spy);
    expect(() => world.update(1 / 60)).not.toThrow();
    expect(spy).not.toHaveBeenCalled();

    vi.unstubAllGlobals();
    world.destroy();
  });
});

// @vitest-environment jsdom
import { describe, it, expect, afterEach } from 'vitest';
import { render } from '@solidjs/testing-library';
import { EventBus, World, MockRendererAdapter } from '@babylonjsmarket/ecs';
import { PlayerInputPanel } from './PlayerInput.panel';
import { createPlayerInput } from './PlayerInput.core';
import { PlayerInputComponent, PlayerInputSystem } from './PlayerInput';
import {
  PlayerInputDebuggerComponent,
  PlayerInputDebuggerSystem,
} from './PlayerInput.viz';
import { vizStore } from '../_shared/viz';

const PANEL_ID = 'player-input-debugger';

describe('PlayerInputPanel mount check', () => {
  it('a stub core can power the panel with no renderer imports', () => {
    const core = createPlayerInput();
    const { container } = render(() => <PlayerInputPanel core={core} />);
    expect(container.textContent).toContain('Active actions');
  });
});

describe('PlayerInputDebuggerComponent', () => {
  it('applies defaults', () => {
    const c = new PlayerInputDebuggerComponent();
    expect(c.visible).toBe(false);
    expect(c.activationKey).toBe('Digit1');
    expect(c.position).toBe('top-right');
    expect(c.serialize()).toEqual({
      visible: false,
      activationKey: 'Digit1',
      position: 'top-right',
    });
  });

  it('round-trips custom config through serialize', () => {
    const c = new PlayerInputDebuggerComponent({
      visible: true,
      activationKey: 'KeyP',
      position: 'bottom-left',
    });
    expect(c.serialize()).toEqual({
      visible: true,
      activationKey: 'KeyP',
      position: 'bottom-left',
    });
  });
});

describe('PlayerInputDebuggerSystem', () => {
  let world: World;

  function makeWorld(): { world: World; eventBus: EventBus } {
    const eventBus = new EventBus();
    const renderer = new MockRendererAdapter();
    world = new World({ eventBus, renderer });
    return { world, eventBus };
  }

  afterEach(() => {
    if (world) world.shutdown();
    vizStore.clear();
    // vizStore persists panel visibility to localStorage; wipe it so panel
    // state can't leak between cases.
    localStorage.clear();
  });

  it('registers the panel once a PlayerInput core exists, and shows it when visible', () => {
    const { world, eventBus } = makeWorld();
    world.createEntity('Debug').add(new PlayerInputDebuggerComponent({ visible: true }));
    world.createEntity('Player').add(new PlayerInputComponent());

    world.addSystem(new PlayerInputSystem(eventBus));
    world.addSystem(new PlayerInputDebuggerSystem(eventBus));
    world.initialize();

    expect(vizStore.panels[PANEL_ID]).toBeDefined();
    expect(vizStore.panels[PANEL_ID].position).toBe('top-right');
    expect(vizStore.panels[PANEL_ID].titleColor).toBe('#66ccff');
    expect(vizStore.isVisible(PANEL_ID)).toBe(true);
  });

  it('defers registration until a PlayerInput core appears, then registers on update', () => {
    const { world, eventBus } = makeWorld();
    world.createEntity('Debug').add(new PlayerInputDebuggerComponent());

    world.addSystem(new PlayerInputDebuggerSystem(eventBus));
    world.initialize();

    // No PlayerInput core yet → nothing registered.
    expect(vizStore.panels[PANEL_ID]).toBeUndefined();

    // Give the entity a component, but its instance is only minted by the
    // PlayerInputSystem; mint it directly so findCoreInstance() succeeds.
    const player = world.createEntity('Player');
    const comp = new PlayerInputComponent();
    comp.instance = createPlayerInput(comp.params);
    player.add(comp);
    world.update(0.016);

    expect(vizStore.panels[PANEL_ID]).toBeDefined();
    expect(vizStore.isVisible(PANEL_ID)).toBe(false);

    // Already registered → a second update is a no-op (idempotent).
    world.update(0.016);
    expect(vizStore.panels[PANEL_ID]).toBeDefined();
  });

  it('stays unregistered while only a component without an instance exists', () => {
    const { world, eventBus } = makeWorld();
    world.createEntity('Debug').add(new PlayerInputDebuggerComponent());
    // Component present but no .instance → findCoreInstance returns null.
    world.createEntity('Player').add(new PlayerInputComponent());

    world.addSystem(new PlayerInputDebuggerSystem(eventBus));
    world.initialize();
    expect(vizStore.panels[PANEL_ID]).toBeUndefined();

    world.update(0.016);
    expect(vizStore.panels[PANEL_ID]).toBeUndefined();
  });

  it('renders the bound panel content for the discovered core', () => {
    const { world, eventBus } = makeWorld();
    world.createEntity('Debug').add(new PlayerInputDebuggerComponent());
    const player = world.createEntity('Player');
    const comp = new PlayerInputComponent();
    comp.instance = createPlayerInput(comp.params);
    player.add(comp);

    world.addSystem(new PlayerInputDebuggerSystem(eventBus));
    world.initialize();

    const { container } = render(() => vizStore.panels[PANEL_ID].content());
    expect(container.textContent).toContain('Active actions');
  });

  it('toggles the panel on the activation key and mirrors visibility onto the component', () => {
    const { world, eventBus } = makeWorld();
    const comp = new PlayerInputDebuggerComponent({ activationKey: 'KeyM' });
    world.createEntity('Debug').add(comp);
    const player = world.createEntity('Player');
    const pic = new PlayerInputComponent();
    pic.instance = createPlayerInput(pic.params);
    player.add(pic);

    world.addSystem(new PlayerInputDebuggerSystem(eventBus));
    world.initialize();

    const evt = new KeyboardEvent('keydown', { code: 'KeyM', cancelable: true });
    window.dispatchEvent(evt);
    expect(evt.defaultPrevented).toBe(true);
    expect(vizStore.isVisible(PANEL_ID)).toBe(true);
    expect(comp.visible).toBe(true);

    window.dispatchEvent(new KeyboardEvent('keydown', { code: 'KeyM' }));
    expect(vizStore.isVisible(PANEL_ID)).toBe(false);
    expect(comp.visible).toBe(false);
  });

  it('ignores key presses that are not the activation key', () => {
    const { world, eventBus } = makeWorld();
    world.createEntity('Debug').add(new PlayerInputDebuggerComponent({ activationKey: 'KeyM' }));
    const player = world.createEntity('Player');
    const pic = new PlayerInputComponent();
    pic.instance = createPlayerInput(pic.params);
    player.add(pic);

    world.addSystem(new PlayerInputDebuggerSystem(eventBus));
    world.initialize();

    window.dispatchEvent(new KeyboardEvent('keydown', { code: 'KeyX' }));
    expect(vizStore.isVisible(PANEL_ID)).toBe(false);
  });

  it('does nothing on a keypress when no debugger component is present', () => {
    const { world, eventBus } = makeWorld();
    // System with no debugger entity: setupKeyboardListener runs but the
    // handler short-circuits because this.component is null.
    world.addSystem(new PlayerInputDebuggerSystem(eventBus));
    world.initialize();

    window.dispatchEvent(new KeyboardEvent('keydown', { code: 'Digit1' }));
    expect(vizStore.panels[PANEL_ID]).toBeUndefined();
  });

  it('adopts a debugger component added after initialization', () => {
    const { world, eventBus } = makeWorld();
    const player = world.createEntity('Player');
    const pic = new PlayerInputComponent();
    pic.instance = createPlayerInput(pic.params);
    player.add(pic);

    world.addSystem(new PlayerInputDebuggerSystem(eventBus));
    world.initialize();
    // No debugger entity at init → no panel.
    expect(vizStore.panels[PANEL_ID]).toBeUndefined();

    world.createEntity('Debug').add(new PlayerInputDebuggerComponent());
    expect(vizStore.panels[PANEL_ID]).toBeDefined();
  });

  it('does not re-adopt a second debugger component once one is held', () => {
    const { world, eventBus } = makeWorld();
    const player = world.createEntity('Player');
    const pic = new PlayerInputComponent();
    pic.instance = createPlayerInput(pic.params);
    player.add(pic);
    world.createEntity('Debug').add(new PlayerInputDebuggerComponent({ activationKey: 'KeyA' }));

    world.addSystem(new PlayerInputDebuggerSystem(eventBus));
    world.initialize();

    // A second debugger entity must not replace the held one.
    world.createEntity('Debug2').add(new PlayerInputDebuggerComponent({ activationKey: 'KeyB' }));

    // The originally-adopted activation key still drives the toggle.
    window.dispatchEvent(new KeyboardEvent('keydown', { code: 'KeyA' }));
    expect(vizStore.isVisible(PANEL_ID)).toBe(true);
  });

  it('removes the panel and the keydown listener on shutdown', () => {
    const { world, eventBus } = makeWorld();
    const comp = new PlayerInputDebuggerComponent({ activationKey: 'KeyM' });
    world.createEntity('Debug').add(comp);
    const player = world.createEntity('Player');
    const pic = new PlayerInputComponent();
    pic.instance = createPlayerInput(pic.params);
    player.add(pic);

    world.addSystem(new PlayerInputDebuggerSystem(eventBus));
    world.initialize();
    expect(vizStore.panels[PANEL_ID]).toBeDefined();

    world.shutdown();
    expect(vizStore.panels[PANEL_ID]).toBeUndefined();

    // Listener is gone → key press no longer reaches the (now-cleared) store.
    window.dispatchEvent(new KeyboardEvent('keydown', { code: 'KeyM' }));
    expect(vizStore.panels[PANEL_ID]).toBeUndefined();
  });
});