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/src/map/state-binding.ts

@@ -0,0 +1,98 @@
+// State binding between the typed game report and the renderer's
+// World. Phase 11 only emits primitives for planets; later phases
+// extend the binding with ship-class reach circles (Phase 17 / 18),
+// hyperspace and incoming groups (Phase 11+ via separate primitives),
+// cargo routes (Phase 16), reach / visibility zones (Phase 17), and
+// battle / bombing markers (Phase 27).
+//
+// The four planet kinds in the report each map to a distinct style so
+// the user can tell own / other-race / uninhabited / unidentified
+// planets apart at a glance. The exact colours are Phase 11 defaults
+// chosen against the dark theme; Phase 35 polish picks final
+// colours and adds theme switching.
+
+import type { GameReport, ReportPlanet } from "../api/game-state";
+import { World, type Primitive, type Style } from "./world";
+
+const STYLE_LOCAL: Style = {
+	fillColor: 0x6dd2ff,
+	fillAlpha: 1,
+	pointRadiusPx: 6,
+};
+
+const STYLE_OTHER: Style = {
+	fillColor: 0xff8a65,
+	fillAlpha: 1,
+	pointRadiusPx: 5,
+};
+
+const STYLE_UNINHABITED: Style = {
+	fillColor: 0xb0bec5,
+	fillAlpha: 0.85,
+	pointRadiusPx: 4,
+};
+
+const STYLE_UNIDENTIFIED: Style = {
+	fillColor: 0x546e7a,
+	fillAlpha: 0.7,
+	pointRadiusPx: 3,
+};
+
+// PlanetIDs occupy the [0, 4_000_000_000) range — well below
+// JavaScript's `Number.MAX_SAFE_INTEGER` — so the engine `number` (uint64)
+// fits in a primitive id (number) without truncation. The binding
+// uses the engine number directly as the primitive id so later phases
+// can resolve a planet by its hit-test result without an extra
+// lookup table.
+function styleFor(kind: ReportPlanet["kind"]): Style {
+	switch (kind) {
+		case "local":
+			return STYLE_LOCAL;
+		case "other":
+			return STYLE_OTHER;
+		case "uninhabited":
+			return STYLE_UNINHABITED;
+		case "unidentified":
+			return STYLE_UNIDENTIFIED;
+	}
+}
+
+function priorityFor(kind: ReportPlanet["kind"]): number {
+	switch (kind) {
+		case "local":
+			return 4;
+		case "other":
+			return 3;
+		case "uninhabited":
+			return 2;
+		case "unidentified":
+			return 1;
+	}
+}
+
+/**
+ * reportToWorld translates a GameReport into a renderer-ready World
+ * containing one Point primitive per planet (all four planet kinds).
+ * The world rectangle matches `report.mapWidth` × `report.mapHeight`.
+ *
+ * If the report carries zero planets (turn-zero edge cases or seeded
+ * tests), the World is still well-formed: the renderer mounts on an
+ * empty primitive list without errors.
+ */
+export function reportToWorld(report: GameReport): World {
+	const primitives: Primitive[] = [];
+	for (const planet of report.planets) {
+		primitives.push({
+			kind: "point",
+			id: planet.number,
+			priority: priorityFor(planet.kind),
+			style: styleFor(planet.kind),
+			hitSlopPx: 0,
+			x: planet.x,
+			y: planet.y,
+		});
+	}
+	const width = report.mapWidth > 0 ? report.mapWidth : 1;
+	const height = report.mapHeight > 0 ? report.mapHeight : 1;
+	return new World(width, height, primitives);
+}