board-game-engine 0.0.7 → 0.0.9

package/e2e/bge.spec.js

@@ -0,0 +1,267 @@
+/**
+ * BoardGameEngine Client e2e tests.
+ */
+import { test, expect } from '@playwright/test'
+import { readFileSync } from 'fs'
+import { join } from 'path'
+
+const FIXTURES = {
+  minimal: '/e2e/fixtures/bge-minimal.html',
+  ttt: '/e2e/fixtures/bge-ttt.html',
+  checkers: '/e2e/fixtures/bge-checkers.html',
+}
+const MINIMAL_GAME_PATH = join(process.cwd(), 'e2e', 'fixtures', 'minimal-game.json')
+const TTT_JSON_PATH = join(process.cwd(), 'examples', 'tic-tac-toe.json')
+const CHECKERS_JSON_PATH = join(process.cwd(), 'examples', 'checkers.json')
+
+test.describe('BoardGameEngine', () => {
+  test('trivial game loads and getState() returns state', async ({ page }) => {
+    test.setTimeout(20000)
+    const minimalJson = readFileSync(MINIMAL_GAME_PATH, 'utf8')
+    await page.route(/minimal-game\.json$/, (route) =>
+      route.fulfill({ contentType: 'application/json', body: minimalJson })
+    )
+    await page.goto(FIXTURES.minimal, { waitUntil: 'load' })
+    await expect(page.getByRole('heading', { name: /BoardGameEngine client – minimal game/i })).toBeVisible()
+
+    const result = await page.evaluate(async () => {
+      const client = window.__bgeMinimalClient
+      if (!client?.getState) return { error: 'no client', hasBGE: !!window.BoardGameEngine }
+      for (let i = 0; i < 50; i++) {
+        const s = client.getState()
+        const G = s?.state?.G ?? s?.G
+        if (G != null) return { gotState: true, G, currentPlayer: s?.state?.ctx?.currentPlayer ?? s?.ctx?.currentPlayer }
+        await new Promise((r) => setTimeout(r, 100))
+      }
+      return { gotState: false, lastGetState: client.getState(), hasBGE: !!window.BoardGameEngine }
+    })
+
+    if (result.error) {
+      expect(result.hasBGE).toBe(true)
+      expect(result.error).toBeUndefined()
+    }
+    expect(result.gotState, result.gotState ? '' : `getState() never had .state.G`).toBe(true)
+    if (result.gotState) {
+      expect(result.G).toBeDefined()
+      expect(typeof result.G).toBe('object')
+      expect(result.currentPlayer).toBeDefined()
+    }
+  })
+
+  test('tic-tac-toe loads and getState() returns state', async ({ page }) => {
+    test.setTimeout(30000)
+    const tttJson = readFileSync(TTT_JSON_PATH, 'utf8')
+    await page.route(/tic-tac-toe\.json$/, (route) =>
+      route.fulfill({ contentType: 'application/json', body: tttJson })
+    )
+    await page.goto(FIXTURES.ttt, { waitUntil: 'load' })
+    await expect(page.getByRole('heading', { name: /BoardGameEngine – tic-tac-toe/i })).toBeVisible()
+
+    const result = await page.evaluate(async () => {
+      const client = window.__bgeTttClient
+      if (!client?.getState) return { error: 'no client' }
+      for (let i = 0; i < 100; i++) {
+        const s = client.getState()
+        if (s?.state?.G != null) return { gotState: true }
+        await new Promise((r) => setTimeout(r, 100))
+      }
+      return { gotState: false }
+    })
+
+    expect(result.error).toBeUndefined()
+    expect(result.gotState).toBe(true)
+  })
+
+  test('tic-tac-toe: getState().allClickable is a non-empty Set', async ({ page }) => {
+    test.setTimeout(20000)
+    const tttJson = readFileSync(TTT_JSON_PATH, 'utf8')
+    await page.route(/tic-tac-toe\.json$/, (route) =>
+      route.fulfill({ contentType: 'application/json', body: tttJson })
+    )
+    await page.goto(FIXTURES.ttt, { waitUntil: 'load' })
+    await expect(page.getByRole('heading', { name: /BoardGameEngine – tic-tac-toe/i })).toBeVisible()
+
+    const result = await page.evaluate(async () => {
+      const client = window.__bgeTttClient
+      if (!client?.getState) return { error: 'no client' }
+      let state = client.getState()
+      for (let i = 0; i < 60; i++) {
+        if (state?.state?.G) break
+        await new Promise((r) => setTimeout(r, 100))
+        state = client.getState()
+      }
+      if (!state?.state?.G) return { error: 'no state' }
+      const allClickable = state.allClickable
+      return { isSet: allClickable instanceof Set, size: allClickable?.size ?? 0 }
+    })
+
+    expect(result.error).toBeUndefined()
+    expect(result.isSet).toBe(true)
+    expect(result.size).toBeGreaterThan(0)
+  })
+
+  test('tic-tac-toe: make a move and assert state changed', async ({ page }) => {
+    test.setTimeout(20000)
+    const tttJson = readFileSync(TTT_JSON_PATH, 'utf8')
+    await page.route(/tic-tac-toe\.json$/, (route) =>
+      route.fulfill({ contentType: 'application/json', body: tttJson })
+    )
+    await page.goto(FIXTURES.ttt, { waitUntil: 'load' })
+    await expect(page.getByRole('heading', { name: /BoardGameEngine – tic-tac-toe/i })).toBeVisible()
+
+    const result = await page.evaluate(async () => {
+      const client = window.__bgeTttClient
+      if (!client?.getState) return { error: 'no client' }
+      let state = client.getState()
+      for (let i = 0; i < 60; i++) {
+        if (state?.state?.G) break
+        await new Promise((r) => setTimeout(r, 100))
+        state = client.getState()
+      }
+      if (!state?.state?.G) return { error: 'no state' }
+      const G = state.state.G
+      const grid = G?.sharedBoard?.entities?.[0]
+      if (!grid?.spaces) return { error: 'no grid spaces' }
+      const placeIndex = grid.spaces.findIndex(s => (s.entities?.length ?? 0) === 0)
+      const emptySpace = placeIndex >= 0 ? grid.spaces[placeIndex] : null
+      if (!emptySpace) return { error: 'no empty space' }
+      const turnBefore = state.state.ctx.turn
+      const currentPlayerBefore = state.state.ctx.currentPlayer
+      if (!client.doStep) return { error: 'no doStep' }
+      client.doStep(emptySpace)
+      await new Promise((r) => setTimeout(r, 200))
+      for (let i = 0; i < 40; i++) {
+        await new Promise((r) => setTimeout(r, 100))
+        const next = client.getState()
+        const turnAfter = next?.state?.ctx?.turn
+        const currentPlayerAfter = next?.state?.ctx?.currentPlayer
+        if (turnAfter !== turnBefore || currentPlayerAfter !== currentPlayerBefore) {
+          const nextGrid = next?.state?.G?.sharedBoard?.entities?.[0]
+          const placedSpace = nextGrid?.spaces?.[placeIndex]
+          const spaceHasEntity = (placedSpace?.entities?.length ?? 0) >= 1
+          return {
+            ok: true,
+            turnBefore,
+            turnAfter,
+            currentPlayerBefore,
+            currentPlayerAfter,
+            spaceHasEntity,
+          }
+        }
+      }
+      return { error: 'state did not change after move', turnBefore, currentPlayerBefore }
+    })
+
+    expect(result.error).toBeUndefined()
+    expect(result.ok).toBe(true)
+    expect(result.turnAfter).toBeGreaterThan(result.turnBefore)
+    expect(result.currentPlayerBefore).toBe('0')
+    expect(result.currentPlayerAfter).toBe('1')
+    expect(result.spaceHasEntity).toBe(true)
+  })
+
+  test('tic-tac-toe: play to game end and check for winner or draw', async ({ page }) => {
+    test.setTimeout(60000)
+    const tttJson = readFileSync(TTT_JSON_PATH, 'utf8')
+    await page.route(/tic-tac-toe\.json$/, (route) =>
+      route.fulfill({ contentType: 'application/json', body: tttJson })
+    )
+    await page.goto(FIXTURES.ttt, { waitUntil: 'load' })
+    await expect(page.getByRole('heading', { name: /BoardGameEngine – tic-tac-toe/i })).toBeVisible()
+
+    const result = await page.evaluate(async () => {
+      const countFilled = (grid) => grid?.spaces?.filter(s => (s?.entities?.length ?? 0) > 0).length ?? 0
+      const client = window.__bgeTttClient
+      if (!client?.getState) return { error: 'no client' }
+      let state = client.getState()
+      for (let i = 0; i < 60; i++) {
+        if (state?.state?.G) break
+        await new Promise((r) => setTimeout(r, 100))
+        state = client.getState()
+      }
+      if (!state?.state?.G) return { error: 'no state' }
+      const grid = state.state.G?.sharedBoard?.entities?.[0]
+      if (!grid?.getSpace) return { error: 'no grid' }
+      if (!client.doStep) return { error: 'no doStep' }
+      const moveOrder = [
+        [0, 0], [1, 0], [2, 0], [0, 1], [1, 1], [0, 2], [2, 1], [2, 2], [1, 2]
+      ]
+      for (let m = 0; m < moveOrder.length; m++) {
+        state = client.getState()
+        if (state?.gameover ?? state?.state?.ctx?.gameover) break
+        const G = state?.state?.G
+        const currentGrid = G?.sharedBoard?.entities?.[0]
+        if (!currentGrid?.getSpace) return { error: `no grid on move ${m + 1}` }
+        const [x, y] = moveOrder[m]
+        const space = currentGrid.getSpace([x, y])
+        if (!space) return { error: `no space at ${x},${y}` }
+        if ((space.entities?.length ?? 0) > 0) continue
+        const turnBefore = state.state.ctx.turn
+        const currentBefore = state.state.ctx.currentPlayer
+        client.doStep(space)
+        for (let poll = 0; poll < 50; poll++) {
+          await new Promise((r) => setTimeout(r, 100))
+          state = client.getState()
+          const gameover = state?.gameover ?? state?.state?.ctx?.gameover
+          if (gameover) {
+            const g = state?.state?.G?.sharedBoard?.entities?.[0]
+            return { ok: true, gameover, winner: gameover?.winner ?? (typeof gameover === 'object' ? gameover.winner : undefined), draw: gameover?.draw, movesPlayed: m + 1, filledCount: countFilled(g) }
+          }
+          if (state?.state?.ctx?.turn !== turnBefore || state?.state?.ctx?.currentPlayer !== currentBefore) break
+        }
+      }
+      for (let i = 0; i < 25; i++) {
+        await new Promise((r) => setTimeout(r, 100))
+        state = client.getState()
+        const gameover = state?.gameover ?? state?.state?.ctx?.gameover
+        if (gameover) {
+          const g = state?.state?.G?.sharedBoard?.entities?.[0]
+          return { ok: true, gameover, winner: gameover?.winner ?? (typeof gameover === 'object' ? gameover.winner : undefined), draw: gameover?.draw, movesPlayed: moveOrder.length, filledCount: countFilled(g) }
+        }
+      }
+      state = client.getState()
+      const ctx = state?.state?.ctx
+      const gameover = state?.gameover ?? ctx?.gameover
+      const finalGrid = state?.state?.G?.sharedBoard?.entities?.[0]
+      return { ok: true, gameover, winner: gameover?.winner, draw: gameover?.draw, movesPlayed: moveOrder.length, lastTurn: ctx?.turn, filledCount: countFilled(finalGrid) }
+    })
+
+    expect(result.error).toBeUndefined()
+    expect(result.ok).toBe(true)
+    expect(result.movesPlayed).toBe(9)
+    expect(result.filledCount).toBe(9)
+    if (result.gameover) {
+      expect(result.gameover).toBeTruthy()
+      if (result.draw) expect(result.draw).toBe(true)
+      else if (result.winner != null) expect(['0', '1']).toContain(result.winner)
+    }
+  })
+
+  test('checkers: getState().allClickable is a non-empty Set', async ({ page }) => {
+    test.setTimeout(30000)
+    const checkersJson = readFileSync(CHECKERS_JSON_PATH, 'utf8')
+    await page.route(/checkers\.json$/, (route) =>
+      route.fulfill({ contentType: 'application/json', body: checkersJson })
+    )
+    await page.goto(FIXTURES.checkers, { waitUntil: 'load' })
+    await expect(page.getByRole('heading', { name: /BoardGameEngine – checkers/i })).toBeVisible()
+
+    const result = await page.evaluate(async () => {
+      const client = window.__bgeCheckersClient
+      if (!client?.getState) return { error: 'no client' }
+      let state = client.getState()
+      for (let i = 0; i < 100; i++) {
+        if (state?.state?.G) break
+        await new Promise((r) => setTimeout(r, 100))
+        state = client.getState()
+      }
+      if (!state?.state?.G) return { error: 'no state' }
+      const allClickable = state.allClickable
+      return { isSet: allClickable instanceof Set, size: allClickable?.size ?? 0 }
+    })
+
+    expect(result.error).toBeUndefined()
+    expect(result.isSet).toBe(true)
+    expect(result.size).toBeGreaterThan(0)
+  })
+})

package/e2e/bgio-minimal.spec.js

@@ -0,0 +1,70 @@
+/**
+ * Minimal boardgame.io client test (no BoardGameEngine).
+ * Loads a trivial game via boardgame.io only to narrow down why the client
+ * doesn't hydrate in headless Firefox.
+ */
+import { test, expect } from '@playwright/test'
+
+const BGIO_MINIMAL_URL = '/e2e/fixtures/bgio-minimal.html'
+const BGIO_MINIMAL_DEBUG_URL = '/e2e/fixtures/bgio-minimal-debug.html'
+
+test.describe('boardgame.io minimal (no BoardGameEngine)', () => {
+  test('bgio client loads and getState() returns state in headless Firefox', async ({ page }) => {
+    test.setTimeout(20000)
+    await page.goto(BGIO_MINIMAL_URL, { waitUntil: 'load' })
+    await expect(page.getByRole('heading', { name: /boardgame\.io client only/i })).toBeVisible()
+
+    const result = await page.evaluate(async () => {
+      const client = window.__bgioMinimalClient
+      if (!client || !client.getState) return { error: 'no client', hasBoardgameIO: !!window.BoardgameIO }
+      let state = client.getState()
+      for (let i = 0; i < 50; i++) {
+        if (state && state.G !== undefined) {
+          return { gotState: true, G: state.G, currentPlayer: state.ctx?.currentPlayer }
+        }
+        await new Promise((r) => setTimeout(r, 100))
+        state = client.getState()
+      }
+      return { gotState: false, lastGetState: state, hasBoardgameIO: !!window.BoardgameIO }
+    })
+
+    if (result.error) {
+      expect(result.hasBoardgameIO, 'BoardgameIO should be on window').toBe(true)
+      expect(result.error).toBeUndefined()
+    }
+    expect(result.gotState, result.gotState ? '' : `getState() never returned .G. lastGetState: ${JSON.stringify(result.lastGetState)}`).toBe(true)
+    if (result.gotState) {
+      expect(result.G).toEqual({ count: 0 })
+      expect(result.currentPlayer).toBeDefined()
+    }
+  })
+
+  test('bgio client with Debug panel loads and getState() returns state', async ({ page }) => {
+    test.setTimeout(25000)
+    await page.goto(BGIO_MINIMAL_DEBUG_URL, { waitUntil: 'load' })
+    await expect(page.getByRole('heading', { name: /boardgame\.io client only \(debug on\)/i })).toBeVisible()
+
+    const result = await page.evaluate(async () => {
+      const client = window.__bgioMinimalClient
+      if (!client || !client.getState) return { error: 'no client', hasBoardgameIO: !!window.BoardgameIO }
+      let state = client.getState()
+      for (let i = 0; i < 80; i++) {
+        if (state && state.G !== undefined) {
+          return { gotState: true, G: state.G, currentPlayer: state.ctx?.currentPlayer }
+        }
+        await new Promise((r) => setTimeout(r, 100))
+        state = client.getState()
+      }
+      return { gotState: false, lastGetState: state, hasBoardgameIO: !!window.BoardgameIO }
+    })
+
+    if (result.error) {
+      expect(result.hasBoardgameIO, 'BoardgameIO should be on window').toBe(true)
+      expect(result.error).toBeUndefined()
+    }
+    expect(result.gotState, result.gotState ? '' : `With Debug: getState() never returned .G. lastGetState: ${JSON.stringify(result.lastGetState)}`).toBe(true)
+    if (result.gotState) {
+      expect(result.G).toEqual({ count: 0 })
+    }
+  })
+})

package/e2e/examples.spec.js

@@ -0,0 +1,34 @@
+/** E2E tests for examples/index.html (Board Game Engine). */
+import { test, expect } from '@playwright/test'
+import { readFileSync } from 'fs'
+import { join } from 'path'
+
+const EXAMPLES_URL = '/examples/index.html'
+const TTT_JSON_PATH = join(process.cwd(), 'examples', 'tic-tac-toe.json')
+
+test.describe('Examples', () => {
+  test('examples page loads with tic-tac-toe selected and Start button', async ({ page }) => {
+    await page.goto(EXAMPLES_URL, { waitUntil: 'load' })
+    await expect(page.getByRole('heading', { name: /Board Game Engine/i })).toBeVisible()
+    await expect(page.locator('#game-select')).toHaveValue('tic-tac-toe')
+    await expect(page.getByRole('button', { name: /Start \/ Reset Game/i })).toBeVisible()
+  })
+
+  test('can load tic-tac-toe and read game config in browser', async ({ page }) => {
+    const tttJson = readFileSync(TTT_JSON_PATH, 'utf8')
+    await page.route(/tic-tac-toe\.json$/, (route) =>
+      route.fulfill({ contentType: 'application/json', body: tttJson })
+    )
+    await page.goto(EXAMPLES_URL, { waitUntil: 'load' })
+
+    const config = await page.evaluate(async () => {
+      const res = await fetch('/examples/tic-tac-toe.json')
+      return res.json()
+    })
+    expect(config.entities).toBeDefined()
+    expect(Array.isArray(config.entities)).toBe(true)
+    expect(config.moves).toBeDefined()
+    expect(config.moves.placePlayerMarker).toBeDefined()
+    expect(config.numPlayers).toBe(2)
+  })
+})

package/e2e/fixtures/bge-checkers.html

@@ -0,0 +1,39 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8" />
+  <title>BoardGameEngine – checkers (debug off)</title>
+</head>
+<body>
+  <h1>BoardGameEngine – checkers</h1>
+  <pre id="out">(waiting…)</pre>
+  <script src="/dist/board-game-engine.js"></script>
+  <script>
+    (async function () {
+      const out = document.getElementById('out');
+      if (!window.BoardGameEngine || !window.BoardGameEngine.Client) {
+        out.textContent = 'BoardGameEngine.Client not found';
+        return;
+      }
+      let gameRules;
+      try {
+        const res = await fetch('/examples/checkers.json');
+        const rules = await res.json();
+        gameRules = JSON.stringify(rules);
+      } catch (e) {
+        out.textContent = 'Fetch failed: ' + (e && e.message);
+        return;
+      }
+      const client = new window.BoardGameEngine.Client({
+        gameRules,
+        gameName: 'checkers',
+        numPlayers: 2,
+        debug: false,
+      });
+      window.__bgeCheckersClient = client;
+      const connected = client.connect();
+      out.textContent = connected ? 'Client connected.' : 'Connect returned falsy.';
+    })();
+  </script>
+</body>
+</html>

package/e2e/fixtures/bge-minimal.html

@@ -0,0 +1,43 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8" />
+  <title>BoardGameEngine client minimal (trivial game)</title>
+</head>
+<body>
+  <h1>BoardGameEngine client – minimal game</h1>
+  <pre id="out">(waiting…)</pre>
+  <script src="/dist/board-game-engine.js"></script>
+  <script>
+    (async function () {
+      const out = document.getElementById('out');
+      if (!window.BoardGameEngine || !window.BoardGameEngine.Client) {
+        out.textContent = 'BoardGameEngine.Client not found';
+        return;
+      }
+      let gameRules;
+      try {
+        const res = await fetch('/e2e/fixtures/minimal-game.json');
+        const rules = await res.json();
+        gameRules = JSON.stringify(rules);
+      } catch (e) {
+        out.textContent = 'Fetch failed: ' + (e && e.message);
+        return;
+      }
+      const client = new window.BoardGameEngine.Client({
+        gameRules,
+        gameName: 'minimal',
+        numPlayers: 2,
+        debug: false,
+        onClientUpdate: () => {
+          const s = client.getState();
+          if (s && s.state) window.__bgeMinimalState = s;
+        },
+      });
+      const connected = client.connect();
+      window.__bgeMinimalClient = connected || client;
+      out.textContent = connected ? 'Client connected.' : 'Connect returned falsy.';
+    })();
+  </script>
+</body>
+</html>

package/e2e/fixtures/bge-ttt.html

@@ -0,0 +1,45 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8" />
+  <title>BoardGameEngine – tic-tac-toe (debug off)</title>
+</head>
+<body>
+  <h1>BoardGameEngine – tic-tac-toe</h1>
+  <pre id="out">(waiting…)</pre>
+  <script src="/dist/board-game-engine.js"></script>
+  <script>
+    (async function () {
+      const out = document.getElementById('out');
+      if (!window.BoardGameEngine || !window.BoardGameEngine.Client) {
+        out.textContent = 'BoardGameEngine.Client not found';
+        return;
+      }
+      let gameRules;
+      try {
+        const res = await fetch('/examples/tic-tac-toe.json');
+        const rules = await res.json();
+        gameRules = JSON.stringify(rules);
+      } catch (e) {
+        out.textContent = 'Fetch failed: ' + (e && e.message);
+        return;
+      }
+      window.__bgeTttGameRulesFetched = true;
+      const client = new window.BoardGameEngine.Client({
+        gameRules,
+        gameName: 'tic-tac-toe',
+        numPlayers: 2,
+        debug: false,
+        onClientUpdate: () => {
+          const s = client.getState();
+          if (s && s.state) window.__bgeTttState = s;
+        },
+      });
+      window.__bgeTttClient = client;
+      const connected = client.connect();
+      window.__bgeTttConnected = !!connected;
+      out.textContent = connected ? 'Client connected.' : 'Connect returned falsy.';
+    })();
+  </script>
+</body>
+</html>

package/e2e/fixtures/bgio-minimal-debug.html

@@ -0,0 +1,47 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8" />
+  <title>boardgame.io minimal with Debug</title>
+</head>
+<body>
+  <h1>boardgame.io client only (debug on)</h1>
+  <pre id="out">(waiting…)</pre>
+  <div id="debug-root"></div>
+  <script src="/node_modules/@mnbroatch/boardgame.io/dist/boardgameio.min.js"></script>
+  <script>
+    (function () {
+      const out = document.getElementById('out');
+      if (!window.BoardgameIO || !window.BoardgameIO.Client) {
+        out.textContent = 'BoardgameIO.Client not found';
+        return;
+      }
+      const Client = window.BoardgameIO.Client;
+      const game = {
+        name: 'minimal',
+        setup: () => ({ count: 0 }),
+        moves: {
+          inc: (G) => ({ ...G, count: G.count + 1 }),
+        },
+      };
+      const debugRoot = document.getElementById('debug-root');
+      const client = Client({
+        game,
+        numPlayers: 2,
+        debug: window.BoardgameIO.Debug ? { impl: window.BoardgameIO.Debug, collapseOnLoad: true } : true,
+        root: debugRoot,
+      });
+      client.subscribe(() => {
+        const state = client.getState();
+        if (state && state.G !== undefined) {
+          window.__bgioMinimalState = state;
+          out.textContent = 'State: ' + JSON.stringify({ G: state.G, ctx: state.ctx });
+        }
+      });
+      client.start();
+      window.__bgioMinimalClient = client;
+      out.textContent = 'Client started (debug on).';
+    })();
+  </script>
+</body>
+</html>

package/e2e/fixtures/bgio-minimal.html

@@ -0,0 +1,44 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8" />
+  <title>boardgame.io minimal (no BoardGameEngine)</title>
+</head>
+<body>
+  <h1>boardgame.io client only</h1>
+  <pre id="out">(waiting…)</pre>
+  <script src="/node_modules/@mnbroatch/boardgame.io/dist/boardgameio.min.js"></script>
+  <script>
+    (function () {
+      const out = document.getElementById('out');
+      if (!window.BoardgameIO || !window.BoardgameIO.Client) {
+        out.textContent = 'BoardgameIO.Client not found';
+        return;
+      }
+      const Client = window.BoardgameIO.Client;
+      const game = {
+        name: 'minimal',
+        setup: () => ({ count: 0 }),
+        moves: {
+          inc: (G) => ({ ...G, count: G.count + 1 }),
+        },
+      };
+      const client = Client({
+        game,
+        numPlayers: 2,
+        debug: false,
+      });
+      client.subscribe(() => {
+        const state = client.getState();
+        if (state && state.G !== undefined) {
+          window.__bgioMinimalState = state;
+          out.textContent = 'State: ' + JSON.stringify({ G: state.G, ctx: state.ctx });
+        }
+      });
+      client.start();
+      window.__bgioMinimalClient = client;
+      out.textContent = 'Client started. Poll getState() or wait for subscribe.';
+    })();
+  </script>
+</body>
+</html>

package/e2e/fixtures/minimal-game.json

@@ -0,0 +1,4 @@
+{
+  "entities": [],
+  "numPlayers": 2
+}