Score

import { runMechanicContract } from '@babylonjsmarket/ecs/testing';
import {
  ScoreComponent,
  ScoreSystem,
  ScoreEvents,
  ScoreInputEvents,
} from './Score';

runMechanicContract({
  name: 'Score',
  componentClass: ScoreComponent,
  systemClass: ScoreSystem,
  sampleInput: { defaultPoints: 3 },
  events: {
    input: [
      ScoreInputEvents.ADD,
      ScoreInputEvents.RESET,
      ScoreInputEvents.GOAL_SCORED,
    ],
    output: [ScoreEvents.CHANGED, ScoreEvents.RESET],
  },
  makeInputPayload(event) {
    if (event === ScoreInputEvents.ADD) return { ownerEntity: 'contract-player', points: 7 };
    if (event === ScoreInputEvents.GOAL_SCORED) return { ownerEntity: 'contract-player', points: 1 };
    return {};
  },
});

import { describe, it, expect } from 'vitest';
import { createScore, DEFAULT_SCORE_PARAMS } from './Score.core';

describe('Score core', () => {
  it('starts with no players and returns zero for unknown entities', () => {
    const s = createScore();
    expect(s.getScore('player1')).toBe(0);
    expect(s.getAllScores()).toEqual({});
  });

  it('addScore applies defaultPoints when no amount is passed', () => {
    const s = createScore({ defaultPoints: 3 });
    const r = s.addScore('player1');
    expect(r.from).toBe(0);
    expect(r.to).toBe(3);
    expect(r.delta).toBe(3);
    expect(s.getScore('player1')).toBe(3);
  });

  it('addScore accumulates points for the same player across calls', () => {
    const s = createScore();
    s.addScore('player1', 10);
    const r = s.addScore('player1', 5);
    expect(r.from).toBe(10);
    expect(r.to).toBe(15);
    expect(s.getScore('player1')).toBe(15);
  });

  it('tracks multiple players independently', () => {
    const s = createScore();
    s.addScore('player1', 10);
    s.addScore('player2', 20);
    s.addScore('player1', 5);
    expect(s.getScore('player1')).toBe(15);
    expect(s.getScore('player2')).toBe(20);
    expect(s.getAllScores()).toEqual({ player1: 15, player2: 20 });
  });

  it('addScore with negative points subtracts from the running total', () => {
    const s = createScore();
    s.addScore('player1', 10);
    const r = s.addScore('player1', -3);
    expect(r.to).toBe(7);
    expect(r.delta).toBe(-3);
  });

  it('clamps additions against maxScore when one is configured', () => {
    const s = createScore({ maxScore: 100 });
    s.addScore('player1', 80);
    const r = s.addScore('player1', 50);
    expect(r.to).toBe(100);
    expect(r.delta).toBe(20);
  });

  it('clamps additions against minScore when one is configured', () => {
    const s = createScore({ minScore: 0 });
    s.addScore('player1', 5);
    const r = s.addScore('player1', -20);
    expect(r.to).toBe(0);
    expect(r.delta).toBe(-5);
  });

  it('getAllScores returns a fresh snapshot that does not alias internal state', () => {
    const s = createScore();
    s.addScore('player1', 10);
    const snap = s.getAllScores();
    snap.player1 = 999;
    expect(s.getScore('player1')).toBe(10);
  });

  it('resetScores clears every player bucket', () => {
    const s = createScore();
    s.addScore('player1', 10);
    s.addScore('player2', 20);
    s.resetScores();
    expect(s.getAllScores()).toEqual({});
    expect(s.getScore('player1')).toBe(0);
  });

  it('accepts initial scores on construction', () => {
    const s = createScore({}, { player1: 5, player2: 12 });
    expect(s.getScore('player1')).toBe(5);
    expect(s.getScore('player2')).toBe(12);
  });

  it('initial scores respect the configured bounds', () => {
    const s = createScore({ maxScore: 10 }, { player1: 99 });
    expect(s.getScore('player1')).toBe(10);
  });

  it('setParams re-clamps existing buckets when bounds tighten', () => {
    const s = createScore();
    s.addScore('player1', 50);
    s.setParams({ maxScore: 20 });
    expect(s.getScore('player1')).toBe(20);
  });

  it('same sequence of addScore calls produces the same state (deterministic)', () => {
    const a = createScore();
    const b = createScore();
    for (const [id, pts] of [
      ['p1', 10],
      ['p2', 5],
      ['p1', -2],
      ['p3', 7],
      ['p2', 10],
    ] as Array<[string, number]>) {
      a.addScore(id, pts);
      b.addScore(id, pts);
    }
    expect(a.getAllScores()).toEqual(b.getAllScores());
  });

  it('reset returns params to defaults and clears every bucket', () => {
    const s = createScore({ defaultPoints: 5, maxScore: 10 });
    s.addScore('player1', 7);
    s.reset();
    expect(s.getParams()).toEqual(DEFAULT_SCORE_PARAMS);
    expect(s.getAllScores()).toEqual({});
  });
});

// @vitest-environment jsdom
import { describe, it, expect, vi } from 'vitest';
import { render, fireEvent } from '@solidjs/testing-library';
import { ScorePanel } from './Score.panel';
import { createScore } from './Score.core';

describe('ScorePanel', () => {
  it('mounts without a renderer and shows the scoreboard + tuning sections', () => {
    const core = createScore();
    const { container } = render(() => <ScorePanel core={core} />);
    expect(container.textContent).toContain('Scoreboard');
    expect(container.textContent).toContain('Award points');
    expect(container.textContent).toContain('defaultPoints');
  });

  it('moving a slider calls core.setParams with the new value', () => {
    const core = createScore();
    const spy = vi.spyOn(core, 'setParams');
    const { getAllByRole } = render(() => <ScorePanel core={core} />);
    const sliders = getAllByRole('slider') as HTMLInputElement[];
    // First slider is defaultPoints.
    fireEvent.input(sliders[0], { target: { value: '5' } });
    expect(spy).toHaveBeenCalledWith(expect.objectContaining({ defaultPoints: 5 }));
  });

  it('the Award button fires onAward when the callback is supplied', () => {
    const core = createScore({ defaultPoints: 3 });
    const onAward = vi.fn();
    const { getByText } = render(() => (
      <ScorePanel core={core} onAward={onAward} players={['player1']} />
    ));
    fireEvent.click(getByText('+3 player1'));
    expect(onAward).toHaveBeenCalledWith('player1', 3);
  });

  it('the Reset scores button fires onResetScores when supplied', () => {
    const core = createScore();
    const onResetScores = vi.fn();
    const { getByText } = render(() => <ScorePanel core={core} onResetScores={onResetScores} />);
    fireEvent.click(getByText('Reset scores'));
    expect(onResetScores).toHaveBeenCalled();
  });

  it('the Reset (params) button clears core params back to defaults', () => {
    const core = createScore({ defaultPoints: 50 });
    const spy = vi.spyOn(core, 'reset');
    const { getByText } = render(() => <ScorePanel core={core} />);
    fireEvent.click(getByText(/reset to defaults/i));
    expect(spy).toHaveBeenCalled();
  });

  it('clears its poll interval when unmounted', () => {
    const core = createScore();
    const clearSpy = vi.spyOn(globalThis, 'clearInterval');
    const { unmount } = render(() => <ScorePanel core={core} />);
    unmount();
    expect(clearSpy).toHaveBeenCalled();
    clearSpy.mockRestore();
  });
});

import { describe, it, expect, beforeEach, vi } from 'vitest';
import {
  ScoreComponent,
  ScoreSystem,
  ScoreEvents,
  ScoreInputEvents,
} from './Score';
import { EventBus, World } from '@babylonjsmarket/ecs';
import { MockRendererAdapter } from '@babylonjsmarket/ecs';

describe('ScoreComponent', () => {
  it('applies defaults', () => {
    const comp = new ScoreComponent();
    expect(comp.params.defaultPoints).toBe(1);
    expect(comp.params.minScore).toBeNull();
    expect(comp.params.maxScore).toBeNull();
    expect(comp.initialScores).toEqual({});
    expect(comp.instance).toBeNull();
  });

  it('accepts seeded scores and param overrides', () => {
    const comp = new ScoreComponent({
      defaultPoints: 3,
      maxScore: 50,
      scores: { player1: 7 },
    });
    expect(comp.params.defaultPoints).toBe(3);
    expect(comp.params.maxScore).toBe(50);
    expect(comp.initialScores).toEqual({ player1: 7 });
  });

  it('serialize round-trips through the constructor', () => {
    const original = new ScoreComponent({
      defaultPoints: 2,
      scores: { player1: 10, player2: 5 },
    });
    const copy = new ScoreComponent(original.serialize());
    expect(copy.params).toEqual(original.params);
    expect(copy.initialScores).toEqual(original.initialScores);
  });
});

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

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

  it('creates a core instance when an entity with ScoreComponent is added', () => {
    const entity = world.createEntity();
    entity.add(new ScoreComponent({ scores: { player1: 3 } }));
    const comp = entity.get(ScoreComponent);
    expect(comp?.instance).not.toBeNull();
    expect(comp?.instance?.getScore('player1')).toBe(3);
  });

  it('emits CHANGED with the new score, delta, and full snapshot on score.add', () => {
    const entity = world.createEntity();
    entity.add(new ScoreComponent());

    const spy = vi.fn();
    eventBus.on(ScoreEvents.CHANGED, spy);

    eventBus.emit(ScoreInputEvents.ADD, { ownerEntity: 'player1', points: 10 });

    expect(spy).toHaveBeenCalledTimes(1);
    expect(spy.mock.calls[0][0]).toMatchObject({
      ownerEntity: 'player1',
      score: 10,
      delta: 10,
      allScores: { player1: 10 },
    });
  });

  it('routes goal.scored payloads through the score core', () => {
    const entity = world.createEntity();
    entity.add(new ScoreComponent());

    const spy = vi.fn();
    eventBus.on(ScoreEvents.CHANGED, spy);

    eventBus.emit(ScoreInputEvents.GOAL_SCORED, {
      ownerEntity: 'player1',
      points: 2,
    });

    expect(spy).toHaveBeenCalledWith(
      expect.objectContaining({ ownerEntity: 'player1', score: 2, delta: 2 }),
    );
  });

  it('accumulates points across multiple add events', () => {
    const entity = world.createEntity();
    entity.add(new ScoreComponent());

    const spy = vi.fn();
    eventBus.on(ScoreEvents.CHANGED, spy);

    eventBus.emit(ScoreInputEvents.ADD, { ownerEntity: 'player1', points: 10 });
    eventBus.emit(ScoreInputEvents.ADD, { ownerEntity: 'player1', points: 5 });

    expect(spy).toHaveBeenCalledTimes(2);
    expect(spy.mock.calls[1][0]).toMatchObject({
      ownerEntity: 'player1',
      score: 15,
    });
  });

  it('handles multiple players independently in allScores payloads', () => {
    const entity = world.createEntity();
    entity.add(new ScoreComponent());

    const spy = vi.fn();
    eventBus.on(ScoreEvents.CHANGED, spy);

    eventBus.emit(ScoreInputEvents.ADD, { ownerEntity: 'player1', points: 10 });
    eventBus.emit(ScoreInputEvents.ADD, { ownerEntity: 'player2', points: 20 });

    expect(spy.mock.calls[1][0].allScores).toEqual({ player1: 10, player2: 20 });
  });

  it('defaults missing points to the component defaultPoints', () => {
    const entity = world.createEntity();
    entity.add(new ScoreComponent({ defaultPoints: 4 }));

    const spy = vi.fn();
    eventBus.on(ScoreEvents.CHANGED, spy);

    eventBus.emit(ScoreInputEvents.ADD, { ownerEntity: 'player1' });

    expect(spy.mock.calls[0][0]).toMatchObject({ score: 4 });
  });

  it('drops add requests without an ownerEntity', () => {
    const entity = world.createEntity();
    entity.add(new ScoreComponent());

    const spy = vi.fn();
    eventBus.on(ScoreEvents.CHANGED, spy);

    eventBus.emit(ScoreInputEvents.ADD, { points: 10 });

    expect(spy).not.toHaveBeenCalled();
  });

  it('emits RESET with an empty snapshot when resetRequest fires', () => {
    const entity = world.createEntity();
    entity.add(new ScoreComponent({ scores: { player1: 10, player2: 20 } }));

    const spy = vi.fn();
    eventBus.on(ScoreEvents.RESET, spy);

    eventBus.emit(ScoreInputEvents.RESET, {});

    expect(spy).toHaveBeenCalledWith({ allScores: {} });
    expect(entity.get(ScoreComponent)?.instance?.getAllScores()).toEqual({});
  });

  it('ignores input events when no scoreboard entity exists', () => {
    // No ScoreComponent entity added: getPrimary() walks to the end and
    // returns null, so add/goal/reset are all no-ops (no events emitted).
    const changed = vi.fn();
    const reset = vi.fn();
    eventBus.on(ScoreEvents.CHANGED, changed);
    eventBus.on(ScoreEvents.RESET, reset);

    eventBus.emit(ScoreInputEvents.ADD, { ownerEntity: 'player1', points: 10 });
    eventBus.emit(ScoreInputEvents.GOAL_SCORED, { ownerEntity: 'player1', points: 5 });
    eventBus.emit(ScoreInputEvents.RESET, {});

    expect(changed).not.toHaveBeenCalled();
    expect(reset).not.toHaveBeenCalled();
  });

  it('does not touch the renderer — Score is data-only', () => {
    const entity = world.createEntity();
    entity.add(new ScoreComponent());
    renderer.calls.length = 0;
    eventBus.emit(ScoreInputEvents.ADD, { ownerEntity: 'player1', points: 10 });
    eventBus.emit(ScoreInputEvents.GOAL_SCORED, { ownerEntity: 'player2', points: 1 });
    eventBus.emit(ScoreInputEvents.RESET, {});
    world.update(0.1);
    expect(renderer.calls).toHaveLength(0);
  });
});

// @vitest-environment jsdom
import { describe, it, expect, vi, afterEach } from 'vitest';
import { render, fireEvent } from '@solidjs/testing-library';
import { EventBus, World, MockRendererAdapter } from '@babylonjsmarket/ecs';
import { ScorePanel } from './Score.panel';
import { createScore } from './Score.core';
import {
  ScoreComponent,
  ScoreSystem,
  ScoreInputEvents,
} from './Score';
import {
  ScoreDebuggerComponent,
  ScoreDebuggerSystem,
} from './Score.viz';
import { vizStore } from '../_shared/viz';

const PANEL_ID = 'score-debugger';

afterEach(() => {
  vizStore.clear();
  localStorage.clear();
});

describe('ScorePanel (renderer-free)', () => {
  it('mounts against a stub core and shows the scoreboard section', () => {
    const core = createScore({}, { player1: 10, player2: 7 });
    const { container } = render(() => <ScorePanel core={core} />);
    expect(container.textContent).toContain('Scoreboard');
    expect(container.textContent).toContain('player1');
    expect(container.textContent).toContain('10');
  });

  it('clicking an Award button fires onAward with the current defaultPoints', () => {
    const core = createScore({ defaultPoints: 5 });
    const onAward = vi.fn();
    const { getByText } = render(() => (
      <ScorePanel core={core} onAward={onAward} players={['player1']} />
    ));
    fireEvent.click(getByText('+5 player1'));
    expect(onAward).toHaveBeenCalledWith('player1', 5);
  });

  it('clicking Reset scores fires onResetScores when supplied', () => {
    const core = createScore();
    const onResetScores = vi.fn();
    const { getByText } = render(() => <ScorePanel core={core} onResetScores={onResetScores} />);
    fireEvent.click(getByText('Reset scores'));
    expect(onResetScores).toHaveBeenCalled();
  });

  // Lines 57-58: award() falls through to core.addScore when no onAward prop.
  it('award button mutates the core directly when no onAward callback is given', () => {
    const core = createScore({ defaultPoints: 3 });
    const addSpy = vi.spyOn(core, 'addScore');
    const { getByText } = render(() => <ScorePanel core={core} players={['player1']} />);
    fireEvent.click(getByText('+3 player1'));
    expect(addSpy).toHaveBeenCalledWith('player1', 3);
    expect(core.getScore('player1')).toBe(3);
  });

  // Lines 66-67: resetScores() falls through to core.resetScores when no onResetScores prop.
  it('reset-scores button clears the core directly when no onResetScores callback is given', () => {
    const core = createScore({}, { player1: 9 });
    const resetSpy = vi.spyOn(core, 'resetScores');
    const { getByText } = render(() => <ScorePanel core={core} players={['player1']} />);
    fireEvent.click(getByText('Reset scores'));
    expect(resetSpy).toHaveBeenCalled();
    expect(core.getAllScores()).toEqual({});
  });

  // Lines 169/177/185: the three tuning sliders' onChange callbacks.
  it('tuning sliders push params into the core (incl. the 0 = null clamp paths)', () => {
    const core = createScore({ defaultPoints: 1, minScore: null, maxScore: null });
    const { container } = render(() => <ScorePanel core={core} />);
    const ranges = container.querySelectorAll('input[type="range"]');
    // Order in the Tuning section: defaultPoints, minScore, maxScore.
    const [defaultPoints, minScore, maxScore] = ranges;

    fireEvent.input(defaultPoints, { target: { value: '8' } });
    expect(core.getParams().defaultPoints).toBe(8);

    // Non-zero value → real clamp bound.
    fireEvent.input(minScore, { target: { value: '-4' } });
    expect(core.getParams().minScore).toBe(-4);
    // Zero → cleared back to null (no clamp).
    fireEvent.input(minScore, { target: { value: '0' } });
    expect(core.getParams().minScore).toBe(null);

    fireEvent.input(maxScore, { target: { value: '50' } });
    expect(core.getParams().maxScore).toBe(50);
    fireEvent.input(maxScore, { target: { value: '0' } });
    expect(core.getParams().maxScore).toBe(null);
  });

  // Line 85: leader() reduce — exercise both ternary branches.
  it('shows the leader for a multi-entry scoreboard (both reduce branches)', () => {
    // Order the buckets so the reduce hits both the "keep best" and the
    // "take current" branch as it folds left-to-right.
    const core = createScore({}, { a: 5, b: 9, c: 2 });
    const { container } = render(() => <ScorePanel core={core} />);
    expect(container.textContent).toContain('Leader: b (9)');
  });
});

describe('ScoreDebuggerComponent', () => {
  it('uses defaults when no data provided', () => {
    const comp = new ScoreDebuggerComponent();
    expect(comp.visible).toBe(false);
    expect(comp.activationKey).toBe('');
    expect(comp.position).toBe('top-right');
    expect(comp.players).toEqual([]);
  });

  it('initializes from provided data', () => {
    const comp = new ScoreDebuggerComponent({
      visible: true,
      activationKey: 'Digit5',
      position: 'bottom-left',
      players: ['p1', 'p2'],
    });
    expect(comp.visible).toBe(true);
    expect(comp.activationKey).toBe('Digit5');
    expect(comp.position).toBe('bottom-left');
    expect(comp.players).toEqual(['p1', 'p2']);
  });

  it('copies the players array (no shared reference)', () => {
    const players = ['p1'];
    const comp = new ScoreDebuggerComponent({ players });
    players.push('p2');
    expect(comp.players).toEqual(['p1']);
  });

  it('serialize round-trips and copies players', () => {
    const comp = new ScoreDebuggerComponent({
      visible: true,
      activationKey: 'KeyZ',
      position: 'bottom-right',
      players: ['a', 'b'],
    });
    const out = comp.serialize();
    expect(out).toEqual({
      visible: true,
      activationKey: 'KeyZ',
      position: 'bottom-right',
      players: ['a', 'b'],
    });
    // Mutating the serialized array must not leak into the component.
    out.players!.push('c');
    expect(comp.players).toEqual(['a', 'b']);

    const reconstructed = new ScoreDebuggerComponent(comp.serialize());
    expect(reconstructed.serialize()).toEqual(comp.serialize());
  });
});

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

  function bootstrap() {
    eventBus = new EventBus();
    renderer = new MockRendererAdapter();
    world = new World({ eventBus, renderer });
    world.addSystem(new ScoreSystem(eventBus));
    world.addSystem(new ScoreDebuggerSystem(eventBus));
    world.initialize();
  }

  afterEach(() => {
    if (world) world.shutdown();
  });

  it('finds an already-present debugger entity during onInitialize', () => {
    // Entities exist BEFORE initialize(), so the system's onInitialize loop
    // discovers the ScoreDebuggerComponent and registers up front.
    eventBus = new EventBus();
    renderer = new MockRendererAdapter();
    world = new World({ eventBus, renderer });
    world.addSystem(new ScoreSystem(eventBus));
    world.addSystem(new ScoreDebuggerSystem(eventBus));
    world.createEntity().add(new ScoreComponent({ scores: { player1: 1 } }));
    world.createEntity().add(new ScoreDebuggerComponent({ visible: true }));
    world.initialize();
    expect(vizStore.panels[PANEL_ID]).toBeDefined();
    expect(vizStore.panels[PANEL_ID].visible).toBe(true);
  });

  it('registers the panel on initialize when a Score core is present', () => {
    bootstrap();
    const scoreEntity = world.createEntity();
    scoreEntity.add(new ScoreComponent({ scores: { player1: 4 } }));
    const dbgEntity = world.createEntity();
    dbgEntity.add(new ScoreDebuggerComponent({ visible: true, position: 'top-left' }));

    const panel = vizStore.panels[PANEL_ID];
    expect(panel).toBeDefined();
    expect(panel.title).toBe('Score');
    expect(panel.position).toBe('top-left');
    expect(panel.visible).toBe(true);
  });

  it('starts hidden when the component is not visible', () => {
    bootstrap();
    world.createEntity().add(new ScoreComponent());
    world.createEntity().add(new ScoreDebuggerComponent({ visible: false }));
    expect(vizStore.panels[PANEL_ID].visible).toBe(false);
  });

  it('defers registration until a Score core exists, then registers on update', () => {
    bootstrap();
    // Debugger present but no ScoreComponent yet → no panel.
    world.createEntity().add(new ScoreDebuggerComponent());
    expect(vizStore.panels[PANEL_ID]).toBeUndefined();

    // Add the score entity; its instance is created on add. The debugger only
    // retries on update().
    world.createEntity().add(new ScoreComponent());
    expect(vizStore.panels[PANEL_ID]).toBeUndefined();

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

  it('does not re-register the panel once registered', () => {
    bootstrap();
    world.createEntity().add(new ScoreComponent());
    world.createEntity().add(new ScoreDebuggerComponent());
    const registerSpy = vi.spyOn(vizStore, 'registerPanel');
    world.update(0.016);
    world.update(0.016);
    expect(registerSpy).not.toHaveBeenCalled();
    registerSpy.mockRestore();
  });

  it('registers when the debugger is added after the score core exists', () => {
    bootstrap();
    // Score core first, then the debugger entity arrives via onEntityAdded.
    world.createEntity().add(new ScoreComponent());
    expect(vizStore.panels[PANEL_ID]).toBeUndefined();
    world.createEntity().add(new ScoreDebuggerComponent({ visible: true }));
    expect(vizStore.panels[PANEL_ID]).toBeDefined();
    expect(vizStore.panels[PANEL_ID].visible).toBe(true);
  });

  it('unregisters the panel on shutdown', () => {
    bootstrap();
    world.createEntity().add(new ScoreComponent());
    world.createEntity().add(new ScoreDebuggerComponent());
    expect(vizStore.panels[PANEL_ID]).toBeDefined();
    world.shutdown();
    expect(vizStore.panels[PANEL_ID]).toBeUndefined();
  });

  it('panel content renders the ScorePanel and wires award/reset to ScoreInputEvents', () => {
    bootstrap();
    world.createEntity().add(new ScoreComponent({ defaultPoints: 7 }));
    world.createEntity().add(
      new ScoreDebuggerComponent({ visible: true, players: ['player1'] }),
    );

    const adds: Array<{ ownerEntity: string; points: number }> = [];
    const resets: unknown[] = [];
    eventBus.on(ScoreInputEvents.ADD, (e) => adds.push(e as never));
    eventBus.on(ScoreInputEvents.RESET, (e) => resets.push(e));

    const panel = vizStore.panels[PANEL_ID];
    const { getByText } = render(() => panel.content() as never);

    fireEvent.click(getByText('+7 player1'));
    expect(adds).toEqual([{ ownerEntity: 'player1', points: 7 }]);

    fireEvent.click(getByText('Reset scores'));
    expect(resets).toHaveLength(1);
  });

  it('renders award buttons for the live score bucket when present', () => {
    bootstrap();
    world.createEntity().add(new ScoreComponent({ scores: { alice: 3 }, defaultPoints: 2 }));
    world.createEntity().add(new ScoreDebuggerComponent({ visible: true }));

    const panel = vizStore.panels[PANEL_ID];
    const { getByText } = render(() => panel.content() as never);
    // Live bucket "alice" drives the award button label.
    expect(getByText('+2 alice')).toBeTruthy();
  });
});