ui/phase-11: map wired to live game state

Replaces the Phase 10 map stub with live planet rendering driven by
`user.games.report`, and wires the header turn counter to the same
data. Phase 11's frontend sits on a per-game `GameStateStore` that
lives in `lib/game-state.svelte.ts`: the in-game shell layout
instantiates one per game, exposes it through Svelte context, and
disposes it on remount. The store discovers the game's current turn
through `lobby.my.games.list`, fetches the matching report, and
exposes a TS-friendly snapshot to the header turn counter, the map
view, and the inspector / order / calculator tabs that later phases
will plug onto the same instance.

The pipeline forced one cross-stage decision: the user surface needs
the current turn number to know which report to fetch, but
`GameSummary` did not expose it. Phase 11 extends the lobby
catalogue (FB schema, transcoder, Go model, backend
gameSummaryWire, gateway decoders, openapi, TS bindings,
api/lobby.ts) with `current_turn:int32`. The data was already
tracked in backend's `RuntimeSnapshot.CurrentTurn`; surfacing it is
a wire change only. Two alternatives were rejected: a brand-new
`user.games.state` message (full wire-flow for one field) and
hard-coding `turn=0` (works for the dev sandbox, which never
advances past zero, but renders the initial state for any real
game). The change crosses Phase 8's already-shipped catalogue per
the project's "decisions baked back into the live plan" rule —
existing tests and fixtures are updated in the same patch.

The state binding lives in `map/state-binding.ts::reportToWorld`:
one Point primitive per planet across all four kinds (local /
other / uninhabited / unidentified) with distinct fill colours,
fill alphas, and point radii so the user can tell them apart at a
glance. The planet engine number is reused as the primitive id so
a hit-test result resolves directly to a planet without an extra
lookup table. Zero-planet reports yield a well-formed empty world;
malformed dimensions fall back to 1×1 so a bad report cannot crash
the renderer.

The map view's mount effect creates the renderer once and skips
re-mount on no-op refreshes (same turn, same wrap mode); a turn
change or wrap-mode flip disposes and recreates it. The renderer's
external API does not yet expose `setWorld`; Phase 24 / 34 will
extract it once high-frequency updates land. The store installs a
`visibilitychange` listener that calls `refresh()` when the tab
regains focus.

Wrap-mode preference uses `Cache` namespace `game-prefs`, key
`<gameId>/wrap-mode`, default `torus`. Phase 11 reads through
`store.wrapMode`; Phase 29 wires the toggle UI on top of
`setWrapMode`.

Tests: Vitest unit coverage for `reportToWorld` (every kind,
ids, styling, empty / zero-dimension edges, priority order) and
for the store lifecycle (init success, missing-membership error,
forbidden-result error, `setTurn`, wrap-mode persistence across
instances, `failBootstrap`). Playwright e2e mocks the gateway for
`lobby.my.games.list` and `user.games.report` and asserts the
live data path: turn counter shows the reported turn,
`active-view-map` flips to `data-status="ready"`, and
`data-planet-count` matches the fixture count. The zero-planet
regression and the missing-membership error path are covered.

Phase 11 status stays `pending` in `ui/PLAN.md` until the local-ci
run lands green; flipping to `done` follows in the next commit per
the per-stage CI gate in `CLAUDE.md`.

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>

ui/frontend/tests/state-binding.test.ts

@@ -0,0 +1,114 @@
+// Vitest unit coverage for `map/state-binding.ts`. The function
+// translates a Phase 11 `GameReport` into a renderer-ready `World`
+// containing one Point primitive per planet across all four kinds
+// (local / other / uninhabited / unidentified). The tests assert
+// the world dimensions match the report, the planet ids are the
+// engine numbers, the kind-specific styles differ, and a zero-planet
+// report still produces a well-formed empty World.
+
+import "@testing-library/jest-dom/vitest";
+import { describe, expect, test } from "vitest";
+
+import type { GameReport } from "../src/api/game-state";
+import { reportToWorld } from "../src/map/state-binding";
+
+function makeReport(overrides: Partial<GameReport> = {}): GameReport {
+	return {
+		turn: 1,
+		mapWidth: 4000,
+		mapHeight: 4000,
+		planetCount: 0,
+		planets: [],
+		...overrides,
+	};
+}
+
+describe("reportToWorld", () => {
+	test("uses report dimensions for the World", () => {
+		const world = reportToWorld(makeReport({ mapWidth: 3200, mapHeight: 1600 }));
+		expect(world.width).toBe(3200);
+		expect(world.height).toBe(1600);
+	});
+
+	test("emits one Point primitive per planet across all four kinds", () => {
+		const world = reportToWorld(
+			makeReport({
+				planets: [
+					{ number: 1, name: "Home", x: 100, y: 100, kind: "local", owner: null, size: 12, resources: 0.5 },
+					{ number: 2, name: "Alpha", x: 200, y: 100, kind: "other", owner: "Federation", size: 8, resources: 0.3 },
+					{ number: 3, name: "Rock", x: 100, y: 200, kind: "uninhabited", owner: null, size: 4, resources: 0.1 },
+					{ number: 4, name: "", x: 200, y: 200, kind: "unidentified", owner: null, size: null, resources: null },
+				],
+			}),
+		);
+		expect(world.primitives.length).toBe(4);
+		for (const p of world.primitives) {
+			expect(p.kind).toBe("point");
+		}
+	});
+
+	test("propagates planet number as primitive id and coordinates verbatim", () => {
+		const world = reportToWorld(
+			makeReport({
+				planets: [
+					{ number: 42, name: "Home", x: 123.5, y: 456.25, kind: "local", owner: null, size: 10, resources: 0.5 },
+				],
+			}),
+		);
+		const [planet] = world.primitives;
+		expect(planet?.id).toBe(42);
+		expect(planet?.kind).toBe("point");
+		if (planet?.kind === "point") {
+			expect(planet.x).toBe(123.5);
+			expect(planet.y).toBe(456.25);
+		}
+	});
+
+	test("uses distinct styles for each planet kind", () => {
+		const world = reportToWorld(
+			makeReport({
+				planets: [
+					{ number: 1, name: "L", x: 0, y: 0, kind: "local", owner: null, size: 1, resources: 0 },
+					{ number: 2, name: "O", x: 1, y: 0, kind: "other", owner: "Foe", size: 1, resources: 0 },
+					{ number: 3, name: "U", x: 2, y: 0, kind: "uninhabited", owner: null, size: 1, resources: 0 },
+					{ number: 4, name: "?", x: 3, y: 0, kind: "unidentified", owner: null, size: null, resources: null },
+				],
+			}),
+		);
+		const fills = world.primitives.map((p) => p.style.fillColor);
+		const unique = new Set(fills);
+		expect(unique.size).toBe(fills.length);
+	});
+
+	test("zero-planet report yields an empty primitive list and well-formed World", () => {
+		const world = reportToWorld(makeReport({ planets: [] }));
+		expect(world.primitives.length).toBe(0);
+		expect(world.width).toBeGreaterThan(0);
+		expect(world.height).toBeGreaterThan(0);
+	});
+
+	test("guards against zero / negative dimensions in the report", () => {
+		const world = reportToWorld(
+			makeReport({ mapWidth: 0, mapHeight: -1, planets: [] }),
+		);
+		// World's constructor rejects non-positive dimensions; the
+		// binding falls back to 1×1 so a malformed report cannot crash
+		// the renderer.
+		expect(world.width).toBeGreaterThan(0);
+		expect(world.height).toBeGreaterThan(0);
+	});
+
+	test("local planets carry higher priority than unidentified", () => {
+		const world = reportToWorld(
+			makeReport({
+				planets: [
+					{ number: 1, name: "Home", x: 0, y: 0, kind: "local", owner: null, size: 1, resources: 0 },
+					{ number: 2, name: "?", x: 0, y: 0, kind: "unidentified", owner: null, size: null, resources: null },
+				],
+			}),
+		);
+		const local = world.primitives.find((p) => p.id === 1);
+		const unknown = world.primitives.find((p) => p.id === 2);
+		expect(local?.priority ?? 0).toBeGreaterThan(unknown?.priority ?? 0);
+	});
+});