@anweather/plugin-board-kit 1.7.0

package/README.md

@@ -0,0 +1,65 @@
+# @anweather/plugin-board-kit
+
+Board-UI primitives for any game board on web-boardgame-platform: a remote
+plugin's frontend bundle (`boardgame-plugins`, `tactics-game-plugin`, the
+platform's own `plugins/tic-tac-toe-remote`) and the native boards still in
+this repo's `frontend/`. One implementation, one package, on the public npm
+registry.
+
+**Published with the SDK, at the SDK's version.** `publish-plugin-sdk.yml`
+releases this package together with `@anweather/game-plugin-ssdk` and the
+Kotlin runtime from one `sdk-v*` tag, so a plugin's board kit, SSDK and
+runtime pin all name the same release. See `plugin-protocol/CLAUDE.md`,
+"Publishing for cross-repo plugins".
+
+**Why a package and not a copy.** A plugin's frontend bundles its own React
+(nothing marked `external`). `react` and `react-dom` are *peer*
+dependencies here, so the consumer's own `node_modules/react` is the one
+this code binds to: exactly one React instance per bundle. The shell-script
+vendoring this replaced existed to dodge the two-React failure a plain
+cross-directory import produced ("Cannot read properties of null (reading
+'useState')" at runtime), and left eight of ten copies stale.
+
+## Contents
+
+- `mountReactBoard(Component, { onError?, fallback? })` returns the
+  `{ mount, update, unmount }` handle a remote bundle exports across the
+  ShadowMount boundary. It wraps the board in an error boundary: a render
+  error shows a message instead of a blank rectangle, is reported through
+  `onError`, and clears on the next `update()`.
+- `BoardShell` (centered-column layout) and `TurnIdentity` (the "You are
+  X" row, with a spectator variant). Inline styles throughout; `TurnIdentity`
+  takes a CSS `color`, never a class name, so it renders the same inside a
+  shadow root with no Tailwind in reach.
+- `computeIsMyTurn` / `computeIsAwaiting` / `computeIsSpectator` over a
+  minimal structural `TurnState` (anything with `lifecycle`,
+  `currentTurnParticipantId`, `participants` and optionally
+  `awaitingParticipantIds`, `GameView` included). `computeIsAwaiting` is
+  what "waiting on me" means during a simultaneous phase.
+- `teamOf` / `teamMembers` for a 4-seat, 2-team, alternating-seat game
+  (mirrors platform-domain's `TeamAssignment`).
+- The display half of platform-domain's `TurnClock`: `useClockNow`,
+  `useClockTimeout`, `formatClock`, `remainingMs`, `clockReading`, and the
+  `ClockBadge` / `StartTurnGate` components. What running out *does* stays
+  the engine's call.
+- `useCanvasCamera`: pinch/wheel zoom and two-finger pan for a
+  canvas-rendered board, renderer-agnostic (Canvas2D via `applyTransform`,
+  or drive a Pixi container from `.zoom`/`.offsetX`/`.offsetY`).
+
+Not here on purpose: `nameplateAccent.ts` (this repo's
+`frontend/src/plugins/`) hardcodes per-`gameType` colours across the native
+catalogue, which is platform logic, not a board primitive.
+
+## Developing
+
+```
+npm ci && npm run build && npm test && npm run typecheck
+```
+
+`npm test` covers the pure helpers (turn, team and clock arithmetic) with
+`node:test`; the components are typechecked and exercised by their
+consumers' own Playwright suites. To try an unpublished change in a
+consumer, `npm pack` here and install the tarball there; the consumer's
+`package.json` should never point at this directory by path, since a
+`file:` link resolves `react` through this directory's own `node_modules`
+and reintroduces the two-React bundle.

package/dist/TurnClockViews.d.ts

@@ -0,0 +1,21 @@
+import { type TurnClockState } from './turnClock';
+/** A participant's clock, compact enough to sit on a scoreboard row. */
+export declare function ClockBadge({ clock, participantId, now, finished }: {
+    clock: TurnClockState;
+    participantId: string;
+    /** From useClockNow. */
+    now: number;
+    finished: boolean;
+}): import("react").JSX.Element;
+/** Shown in place of whatever the player could plan their move from,
+ *  until they start their turn. In place of, not over: a blurred board is
+ *  still in the DOM, and anyone with devtools can read it off the clock.
+ *  [detail] says what running over will cost, in the game's own terms. */
+export declare function StartTurnGate({ onStart, pending, hidden, detail }: {
+    onStart: () => void;
+    pending: boolean;
+    /** What is being kept out of sight, e.g. "board and rack". */
+    hidden: string;
+    detail?: string;
+}): import("react").JSX.Element;
+//# sourceMappingURL=TurnClockViews.d.ts.map

package/dist/TurnClockViews.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TurnClockViews.d.ts","sourceRoot":"","sources":["../src/TurnClockViews.tsx"],"names":[],"mappings":"AAAA,OAAO,EAA6B,KAAK,cAAc,EAAE,MAAM,aAAa,CAAA;AAM5E,wEAAwE;AACxE,wBAAgB,UAAU,CAAC,EAAE,KAAK,EAAE,aAAa,EAAE,GAAG,EAAE,QAAQ,EAAE,EAAE;IAClE,KAAK,EAAE,cAAc,CAAA;IACrB,aAAa,EAAE,MAAM,CAAA;IACrB,wBAAwB;IACxB,GAAG,EAAE,MAAM,CAAA;IACX,QAAQ,EAAE,OAAO,CAAA;CAClB,+BAqBA;AAED;;;0EAG0E;AAC1E,wBAAgB,aAAa,CAAC,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,EAAE;IAClE,OAAO,EAAE,MAAM,IAAI,CAAA;IACnB,OAAO,EAAE,OAAO,CAAA;IAChB,8DAA8D;IAC9D,MAAM,EAAE,MAAM,CAAA;IACd,MAAM,CAAC,EAAE,MAAM,CAAA;CAChB,+BAwCA"}

package/dist/TurnClockViews.js

@@ -0,0 +1,48 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { clockReading, formatClock } from './turnClock';
+// The components half of turnClock.ts. Inline styles only, like
+// BoardShell: this file is vendored into plugin bundles that render
+// inside a ShadowMount with no Tailwind in reach.
+/** A participant's clock, compact enough to sit on a scoreboard row. */
+export function ClockBadge({ clock, participantId, now, finished }) {
+    const reading = clockReading(clock, participantId, now);
+    const ticking = reading.ticking && !finished;
+    return (_jsxs("span", { "data-testid": `turn-clock-${participantId}`, title: reading.countingDown ? 'Time left' : 'Time used', style: {
+            fontVariantNumeric: 'tabular-nums',
+            fontWeight: 600,
+            padding: '1px 6px',
+            borderRadius: 4,
+            border: `1px solid ${ticking ? '#34d399' : '#334155'}`,
+            color: reading.overrun ? '#fb7185' : '#e2e8f0',
+            whiteSpace: 'nowrap',
+        }, children: [ticking && _jsx("span", { style: { color: '#34d399', marginRight: 4 }, children: "\u25CF" }), formatClock(reading.ms)] }));
+}
+/** Shown in place of whatever the player could plan their move from,
+ *  until they start their turn. In place of, not over: a blurred board is
+ *  still in the DOM, and anyone with devtools can read it off the clock.
+ *  [detail] says what running over will cost, in the game's own terms. */
+export function StartTurnGate({ onStart, pending, hidden, detail }) {
+    return (_jsxs("div", { style: {
+            display: 'flex',
+            flexDirection: 'column',
+            alignItems: 'center',
+            gap: 12,
+            padding: '40px 16px',
+            width: '100%',
+            boxSizing: 'border-box',
+            borderRadius: 8,
+            border: '1px solid #334155',
+            background: 'rgba(15, 23, 42, 0.6)',
+            textAlign: 'center',
+        }, children: [_jsxs("p", { style: { margin: 0, color: '#cbd5e1', fontSize: 14 }, children: ["Your ", hidden, " stay hidden until you start your turn."] }), _jsx("button", { onClick: onStart, disabled: pending, "data-testid": "start-turn", style: {
+                    padding: '8px 20px',
+                    borderRadius: 6,
+                    border: 'none',
+                    background: '#047857',
+                    color: 'white',
+                    fontWeight: 600,
+                    cursor: pending ? 'not-allowed' : 'pointer',
+                    opacity: pending ? 0.4 : 1,
+                }, children: pending ? 'Starting…' : 'Start my turn' }), _jsxs("p", { style: { margin: 0, color: '#64748b', fontSize: 12 }, children: ["Your clock runs from the moment you press this until you move.", detail ? ` ${detail}` : ''] })] }));
+}
+//# sourceMappingURL=TurnClockViews.js.map

package/dist/TurnClockViews.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"TurnClockViews.js","sourceRoot":"","sources":["../src/TurnClockViews.tsx"],"names":[],"mappings":";AAAA,OAAO,EAAE,YAAY,EAAE,WAAW,EAAuB,MAAM,aAAa,CAAA;AAE5E,gEAAgE;AAChE,oEAAoE;AACpE,kDAAkD;AAElD,wEAAwE;AACxE,MAAM,UAAU,UAAU,CAAC,EAAE,KAAK,EAAE,aAAa,EAAE,GAAG,EAAE,QAAQ,EAM/D;IACC,MAAM,OAAO,GAAG,YAAY,CAAC,KAAK,EAAE,aAAa,EAAE,GAAG,CAAC,CAAA;IACvD,MAAM,OAAO,GAAG,OAAO,CAAC,OAAO,IAAI,CAAC,QAAQ,CAAA;IAC5C,OAAO,CACL,+BACe,cAAc,aAAa,EAAE,EAC1C,KAAK,EAAE,OAAO,CAAC,YAAY,CAAC,CAAC,CAAC,WAAW,CAAC,CAAC,CAAC,WAAW,EACvD,KAAK,EAAE;YACL,kBAAkB,EAAE,cAAc;YAClC,UAAU,EAAE,GAAG;YACf,OAAO,EAAE,SAAS;YAClB,YAAY,EAAE,CAAC;YACf,MAAM,EAAE,aAAa,OAAO,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,SAAS,EAAE;YACtD,KAAK,EAAE,OAAO,CAAC,OAAO,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,SAAS;YAC9C,UAAU,EAAE,QAAQ;SACrB,aAEA,OAAO,IAAI,eAAM,KAAK,EAAE,EAAE,KAAK,EAAE,SAAS,EAAE,WAAW,EAAE,CAAC,EAAE,uBAAU,EACtE,WAAW,CAAC,OAAO,CAAC,EAAE,CAAC,IACnB,CACR,CAAA;AACH,CAAC;AAED;;;0EAG0E;AAC1E,MAAM,UAAU,aAAa,CAAC,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,EAM/D;IACC,OAAO,CACL,eACE,KAAK,EAAE;YACL,OAAO,EAAE,MAAM;YACf,aAAa,EAAE,QAAQ;YACvB,UAAU,EAAE,QAAQ;YACpB,GAAG,EAAE,EAAE;YACP,OAAO,EAAE,WAAW;YACpB,KAAK,EAAE,MAAM;YACb,SAAS,EAAE,YAAY;YACvB,YAAY,EAAE,CAAC;YACf,MAAM,EAAE,mBAAmB;YAC3B,UAAU,EAAE,uBAAuB;YACnC,SAAS,EAAE,QAAQ;SACpB,aAED,aAAG,KAAK,EAAE,EAAE,MAAM,EAAE,CAAC,EAAE,KAAK,EAAE,SAAS,EAAE,QAAQ,EAAE,EAAE,EAAE,sBAAQ,MAAM,+CAA4C,EACjH,iBACE,OAAO,EAAE,OAAO,EAChB,QAAQ,EAAE,OAAO,iBACL,YAAY,EACxB,KAAK,EAAE;oBACL,OAAO,EAAE,UAAU;oBACnB,YAAY,EAAE,CAAC;oBACf,MAAM,EAAE,MAAM;oBACd,UAAU,EAAE,SAAS;oBACrB,KAAK,EAAE,OAAO;oBACd,UAAU,EAAE,GAAG;oBACf,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC,aAAa,CAAC,CAAC,CAAC,SAAS;oBAC3C,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;iBAC3B,YAEA,OAAO,CAAC,CAAC,CAAC,WAAW,CAAC,CAAC,CAAC,eAAe,GACjC,EACT,aAAG,KAAK,EAAE,EAAE,MAAM,EAAE,CAAC,EAAE,KAAK,EAAE,SAAS,EAAE,QAAQ,EAAE,EAAE,EAAE,+EACU,MAAM,CAAC,CAAC,CAAC,IAAI,MAAM,EAAE,CAAC,CAAC,CAAC,EAAE,IACvF,IACA,CACP,CAAA;AACH,CAAC"}

package/dist/boardShared.d.ts

@@ -0,0 +1,27 @@
+import type { ReactNode } from 'react';
+/** Shared outer layout for the simple (non-card) board plugins: a centered
+ *  column with consistent spacing between the identity row, the board
+ *  itself, and any status/action elements below it. Inline styles, not
+ *  Tailwind classNames, like everything in this package: it renders the
+ *  same inside a remote plugin's ShadowMount shadow root (which the
+ *  platform's Tailwind stylesheet never reaches) and on a native board. */
+export declare function BoardShell({ children }: {
+    children: ReactNode;
+}): import("react").JSX.Element;
+/** The "You are <color/symbol>" row shown above most simple boards. A
+ *  spectator isn't any of the game's sides, so [spectating] swaps in a
+ *  neutral line instead of the caller's (necessarily wrong, since it
+ *  defaults to one side or the other) color/symbol guess.
+ *
+ *  [color] is a CSS colour value (`#fb7185`, `rgb(...)`, a variable), never
+ *  a class name: this renders inline styles, so it looks the same inside
+ *  a remote plugin's ShadowMount shadow root, which the platform's
+ *  Tailwind stylesheet never reaches, as it does on a native board. The
+ *  earlier `colorClass` prop took a Tailwind class and rendered an
+ *  unstyled line in every remote plugin. */
+export declare function TurnIdentity({ label, color, spectating }: {
+    label: ReactNode;
+    color?: string;
+    spectating?: boolean;
+}): import("react").JSX.Element;
+//# sourceMappingURL=boardShared.d.ts.map

package/dist/boardShared.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"boardShared.d.ts","sourceRoot":"","sources":["../src/boardShared.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,OAAO,CAAA;AAEtC;;;;;2EAK2E;AAC3E,wBAAgB,UAAU,CAAC,EAAE,QAAQ,EAAE,EAAE;IAAE,QAAQ,EAAE,SAAS,CAAA;CAAE,+BAiB/D;AAED;;;;;;;;;;4CAU4C;AAC5C,wBAAgB,YAAY,CAAC,EAAE,KAAK,EAAE,KAAiB,EAAE,UAAkB,EAAE,EAAE;IAC7E,KAAK,EAAE,SAAS,CAAA;IAChB,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,UAAU,CAAC,EAAE,OAAO,CAAA;CACrB,+BAUA"}

package/dist/boardShared.js

@@ -0,0 +1,40 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/** Shared outer layout for the simple (non-card) board plugins: a centered
+ *  column with consistent spacing between the identity row, the board
+ *  itself, and any status/action elements below it. Inline styles, not
+ *  Tailwind classNames, like everything in this package: it renders the
+ *  same inside a remote plugin's ShadowMount shadow root (which the
+ *  platform's Tailwind stylesheet never reaches) and on a native board. */
+export function BoardShell({ children }) {
+    // minWidth: 0 lets this shrink below its content's intrinsic width when
+    // the page is narrower than the board (e.g. Words with Nerds' 15-wide
+    // grid); without it, a flex item's default auto min-width refuses to
+    // shrink, so an oversized board pokes past its container and gets
+    // clipped by GamePage's overflow-hidden card instead of scrolling
+    // internally.
+    // fontFamily set explicitly (not just relying on an inherited page
+    // font) since a remote plugin's shadow root inherits nothing from the
+    // platform's own stylesheet -- without this, an otherwise-unstyled
+    // remote board falls back to the browser's default serif font instead
+    // of matching the platform's look.
+    return (_jsx("div", { style: { display: 'flex', flexDirection: 'column', alignItems: 'center', gap: 16, minWidth: 0, width: '100%', fontFamily: 'system-ui, sans-serif' }, children: children }));
+}
+/** The "You are <color/symbol>" row shown above most simple boards. A
+ *  spectator isn't any of the game's sides, so [spectating] swaps in a
+ *  neutral line instead of the caller's (necessarily wrong, since it
+ *  defaults to one side or the other) color/symbol guess.
+ *
+ *  [color] is a CSS colour value (`#fb7185`, `rgb(...)`, a variable), never
+ *  a class name: this renders inline styles, so it looks the same inside
+ *  a remote plugin's ShadowMount shadow root, which the platform's
+ *  Tailwind stylesheet never reaches, as it does on a native board. The
+ *  earlier `colorClass` prop took a Tailwind class and rendered an
+ *  unstyled line in every remote plugin. */
+export function TurnIdentity({ label, color = '#ffffff', spectating = false }) {
+    const row = { fontSize: 14, lineHeight: '20px', color: '#94a3b8' };
+    if (spectating) {
+        return _jsx("div", { style: row, children: "\uD83D\uDC40 Spectating" });
+    }
+    return (_jsxs("div", { style: row, children: ["You are ", _jsx("span", { style: { fontWeight: 700, color }, children: label })] }));
+}
+//# sourceMappingURL=boardShared.js.map

package/dist/boardShared.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"boardShared.js","sourceRoot":"","sources":["../src/boardShared.tsx"],"names":[],"mappings":";AAEA;;;;;2EAK2E;AAC3E,MAAM,UAAU,UAAU,CAAC,EAAE,QAAQ,EAA2B;IAC9D,wEAAwE;IACxE,sEAAsE;IACtE,qEAAqE;IACrE,kEAAkE;IAClE,kEAAkE;IAClE,cAAc;IACd,mEAAmE;IACnE,sEAAsE;IACtE,mEAAmE;IACnE,sEAAsE;IACtE,mCAAmC;IACnC,OAAO,CACL,cAAK,KAAK,EAAE,EAAE,OAAO,EAAE,MAAM,EAAE,aAAa,EAAE,QAAQ,EAAE,UAAU,EAAE,QAAQ,EAAE,GAAG,EAAE,EAAE,EAAE,QAAQ,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,EAAE,UAAU,EAAE,uBAAuB,EAAE,YACrJ,QAAQ,GACL,CACP,CAAA;AACH,CAAC;AAED;;;;;;;;;;4CAU4C;AAC5C,MAAM,UAAU,YAAY,CAAC,EAAE,KAAK,EAAE,KAAK,GAAG,SAAS,EAAE,UAAU,GAAG,KAAK,EAI1E;IACC,MAAM,GAAG,GAAG,EAAE,QAAQ,EAAE,EAAE,EAAE,UAAU,EAAE,MAAM,EAAE,KAAK,EAAE,SAAS,EAAW,CAAA;IAC3E,IAAI,UAAU,EAAE,CAAC;QACf,OAAO,cAAK,KAAK,EAAE,GAAG,wCAAqB,CAAA;IAC7C,CAAC;IACD,OAAO,CACL,eAAK,KAAK,EAAE,GAAG,yBACL,eAAM,KAAK,EAAE,EAAE,UAAU,EAAE,GAAG,EAAE,KAAK,EAAE,YAAG,KAAK,GAAQ,IAC3D,CACP,CAAA;AACH,CAAC"}

package/dist/index.d.ts

@@ -0,0 +1,13 @@
+export { mountReactBoard } from './mountReactBoard';
+export type { RemoteBoardHandle, MountReactBoardOptions } from './mountReactBoard';
+export { BoardShell, TurnIdentity } from './boardShared';
+export { computeIsMyTurn, computeIsAwaiting, computeIsSpectator } from './turnUtils';
+export type { TurnState } from './turnUtils';
+export { teamOf, teamMembers } from './teamUtils';
+export type { TeamId } from './teamUtils';
+export { useClockNow, useClockTimeout, formatClock, liveUsedMs, remainingMs, clockReading } from './turnClock';
+export type { TurnClockState } from './turnClock';
+export { ClockBadge, StartTurnGate } from './TurnClockViews';
+export { useCanvasCamera } from './useCanvasCamera';
+export type { Vec2, UseCanvasCameraOptions, CanvasCamera } from './useCanvasCamera';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAA;AACnD,YAAY,EAAE,iBAAiB,EAAE,sBAAsB,EAAE,MAAM,mBAAmB,CAAA;AAClF,OAAO,EAAE,UAAU,EAAE,YAAY,EAAE,MAAM,eAAe,CAAA;AACxD,OAAO,EAAE,eAAe,EAAE,iBAAiB,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAA;AACpF,YAAY,EAAE,SAAS,EAAE,MAAM,aAAa,CAAA;AAC5C,OAAO,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,aAAa,CAAA;AACjD,YAAY,EAAE,MAAM,EAAE,MAAM,aAAa,CAAA;AACzC,OAAO,EAAE,WAAW,EAAE,eAAe,EAAE,WAAW,EAAE,UAAU,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,aAAa,CAAA;AAC9G,YAAY,EAAE,cAAc,EAAE,MAAM,aAAa,CAAA;AACjD,OAAO,EAAE,UAAU,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAA;AAC5D,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAA;AACnD,YAAY,EAAE,IAAI,EAAE,sBAAsB,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAA"}

package/dist/index.js

@@ -0,0 +1,12 @@
+// @anweather/plugin-board-kit -- everything a game board needs from the
+// platform side, as one package. See README.md for what each piece is and
+// plugin-protocol/CLAUDE.md, "Publishing for cross-repo plugins", for how
+// it is released (one semver with the SDK).
+export { mountReactBoard } from './mountReactBoard';
+export { BoardShell, TurnIdentity } from './boardShared';
+export { computeIsMyTurn, computeIsAwaiting, computeIsSpectator } from './turnUtils';
+export { teamOf, teamMembers } from './teamUtils';
+export { useClockNow, useClockTimeout, formatClock, liveUsedMs, remainingMs, clockReading } from './turnClock';
+export { ClockBadge, StartTurnGate } from './TurnClockViews';
+export { useCanvasCamera } from './useCanvasCamera';
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,wEAAwE;AACxE,0EAA0E;AAC1E,0EAA0E;AAC1E,4CAA4C;AAC5C,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAA;AAEnD,OAAO,EAAE,UAAU,EAAE,YAAY,EAAE,MAAM,eAAe,CAAA;AACxD,OAAO,EAAE,eAAe,EAAE,iBAAiB,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAA;AAEpF,OAAO,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,aAAa,CAAA;AAEjD,OAAO,EAAE,WAAW,EAAE,eAAe,EAAE,WAAW,EAAE,UAAU,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,aAAa,CAAA;AAE9G,OAAO,EAAE,UAAU,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAA;AAC5D,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAA"}

package/dist/mountReactBoard.d.ts

@@ -0,0 +1,24 @@
+import { type ComponentType, type ErrorInfo, type ReactNode } from 'react';
+/** The imperative mount/update/unmount contract every remote plugin's
+ *  frontend bundle exports across the ShadowMount boundary (see
+ *  web-boardgame-platform's plugins/CLAUDE.md "Frontend bundle" section
+ *  for why it's imperative rather than a shared React tree). Single
+ *  module-level root: fine for one game page mounted at a time; a second
+ *  concurrent instance would need its own handle instead of sharing this
+ *  closure's state. */
+export interface RemoteBoardHandle<Props> {
+    mount(container: HTMLElement, props: Props): void;
+    update(props: Props): void;
+    unmount(): void;
+}
+export interface MountReactBoardOptions {
+    /** Called once per render error the board throws. The platform shell
+     *  never sees an exception from inside a ShadowMount, so without this a
+     *  crashed board is a blank rectangle and nothing else. */
+    onError?: (error: Error, info: ErrorInfo) => void;
+    /** What to show in place of a board that threw. Defaults to a plain
+     *  message naming the error. */
+    fallback?: (error: Error) => ReactNode;
+}
+export declare function mountReactBoard<Props extends object>(BoardComponent: ComponentType<Props>, options?: MountReactBoardOptions): RemoteBoardHandle<Props>;
+//# sourceMappingURL=mountReactBoard.d.ts.map

package/dist/mountReactBoard.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mountReactBoard.d.ts","sourceRoot":"","sources":["../src/mountReactBoard.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAa,KAAK,aAAa,EAAE,KAAK,SAAS,EAAE,KAAK,SAAS,EAAE,MAAM,OAAO,CAAA;AAGrF;;;;;;uBAMuB;AACvB,MAAM,WAAW,iBAAiB,CAAC,KAAK;IACtC,KAAK,CAAC,SAAS,EAAE,WAAW,EAAE,KAAK,EAAE,KAAK,GAAG,IAAI,CAAA;IACjD,MAAM,CAAC,KAAK,EAAE,KAAK,GAAG,IAAI,CAAA;IAC1B,OAAO,IAAI,IAAI,CAAA;CAChB;AAED,MAAM,WAAW,sBAAsB;IACrC;;+DAE2D;IAC3D,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,KAAK,EAAE,IAAI,EAAE,SAAS,KAAK,IAAI,CAAA;IACjD;oCACgC;IAChC,QAAQ,CAAC,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,SAAS,CAAA;CACvC;AAgDD,wBAAgB,eAAe,CAAC,KAAK,SAAS,MAAM,EAClD,cAAc,EAAE,aAAa,CAAC,KAAK,CAAC,EACpC,OAAO,GAAE,sBAA2B,GACnC,iBAAiB,CAAC,KAAK,CAAC,CA0B1B"}

package/dist/mountReactBoard.js

@@ -0,0 +1,46 @@
+import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
+import { Component } from 'react';
+import { createRoot } from 'react-dom/client';
+/** A board that throws during render must not take the whole game page
+ *  with it, and must recover when the next view arrives: ShadowMount has
+ *  no boundary of its own on the far side of the mount() call. */
+class BoardErrorBoundary extends Component {
+    state = { error: null, attempt: 0 };
+    static getDerivedStateFromError(error) {
+        return { error };
+    }
+    static getDerivedStateFromProps(props, state) {
+        // A new attempt (an update() with fresh props) clears the last error.
+        return props.attempt !== state.attempt ? { error: null, attempt: props.attempt } : null;
+    }
+    componentDidCatch(error, info) {
+        this.props.onError?.(error, info);
+    }
+    render() {
+        return this.state.error ? this.props.fallback(this.state.error) : this.props.children;
+    }
+}
+function defaultFallback(error) {
+    return (_jsxs("div", { role: "alert", style: { padding: 16, fontFamily: 'system-ui, sans-serif', color: '#fb7185' }, children: ["This board hit an error and could not draw itself: ", error.message] }));
+}
+export function mountReactBoard(BoardComponent, options = {}) {
+    let root = null;
+    let attempt = 0;
+    const fallback = options.fallback ?? defaultFallback;
+    const render = (props) => root?.render(_jsx(BoardErrorBoundary, { onError: options.onError, fallback: fallback, attempt: attempt, children: _jsx(BoardComponent, { ...props }) }));
+    return {
+        mount(container, props) {
+            root = createRoot(container);
+            render(props);
+        },
+        update(props) {
+            attempt += 1;
+            render(props);
+        },
+        unmount() {
+            root?.unmount();
+            root = null;
+        },
+    };
+}
+//# sourceMappingURL=mountReactBoard.js.map

package/dist/mountReactBoard.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mountReactBoard.js","sourceRoot":"","sources":["../src/mountReactBoard.tsx"],"names":[],"mappings":";AAAA,OAAO,EAAE,SAAS,EAAsD,MAAM,OAAO,CAAA;AACrF,OAAO,EAAE,UAAU,EAAa,MAAM,kBAAkB,CAAA;AAuCxD;;kEAEkE;AAClE,MAAM,kBAAmB,SAAQ,SAAuC;IACtE,KAAK,GAAkB,EAAE,KAAK,EAAE,IAAI,EAAE,OAAO,EAAE,CAAC,EAAE,CAAA;IAElD,MAAM,CAAC,wBAAwB,CAAC,KAAY;QAC1C,OAAO,EAAE,KAAK,EAAE,CAAA;IAClB,CAAC;IAED,MAAM,CAAC,wBAAwB,CAAC,KAAoB,EAAE,KAAoB;QACxE,sEAAsE;QACtE,OAAO,KAAK,CAAC,OAAO,KAAK,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,IAAI,EAAE,OAAO,EAAE,KAAK,CAAC,OAAO,EAAE,CAAC,CAAC,CAAC,IAAI,CAAA;IACzF,CAAC;IAED,iBAAiB,CAAC,KAAY,EAAE,IAAe;QAC7C,IAAI,CAAC,KAAK,CAAC,OAAO,EAAE,CAAC,KAAK,EAAE,IAAI,CAAC,CAAA;IACnC,CAAC;IAED,MAAM;QACJ,OAAO,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAA;IACvF,CAAC;CACF;AAED,SAAS,eAAe,CAAC,KAAY;IACnC,OAAO,CACL,eAAK,IAAI,EAAC,OAAO,EAAC,KAAK,EAAE,EAAE,OAAO,EAAE,EAAE,EAAE,UAAU,EAAE,uBAAuB,EAAE,KAAK,EAAE,SAAS,EAAE,oEACzC,KAAK,CAAC,OAAO,IAC7D,CACP,CAAA;AACH,CAAC;AAED,MAAM,UAAU,eAAe,CAC7B,cAAoC,EACpC,UAAkC,EAAE;IAEpC,IAAI,IAAI,GAAgB,IAAI,CAAA;IAC5B,IAAI,OAAO,GAAG,CAAC,CAAA;IACf,MAAM,QAAQ,GAAG,OAAO,CAAC,QAAQ,IAAI,eAAe,CAAA;IAEpD,MAAM,MAAM,GAAG,CAAC,KAAY,EAAE,EAAE,CAC9B,IAAI,EAAE,MAAM,CACV,KAAC,kBAAkB,IAAC,OAAO,EAAE,OAAO,CAAC,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,OAAO,EAAE,OAAO,YAChF,KAAC,cAAc,OAAK,KAAK,GAAI,GACV,CACtB,CAAA;IAEH,OAAO;QACL,KAAK,CAAC,SAAS,EAAE,KAAK;YACpB,IAAI,GAAG,UAAU,CAAC,SAAS,CAAC,CAAA;YAC5B,MAAM,CAAC,KAAK,CAAC,CAAA;QACf,CAAC;QACD,MAAM,CAAC,KAAK;YACV,OAAO,IAAI,CAAC,CAAA;YACZ,MAAM,CAAC,KAAK,CAAC,CAAA;QACf,CAAC;QACD,OAAO;YACL,IAAI,EAAE,OAAO,EAAE,CAAA;YACf,IAAI,GAAG,IAAI,CAAA;QACb,CAAC;KACF,CAAA;AACH,CAAC"}

package/dist/teamUtils.d.ts

@@ -0,0 +1,4 @@
+export type TeamId = '1' | '2';
+export declare function teamOf(turnOrder: string[], participantId: string): TeamId;
+export declare function teamMembers(turnOrder: string[], team: TeamId): string[];
+//# sourceMappingURL=teamUtils.d.ts.map

package/dist/teamUtils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"teamUtils.d.ts","sourceRoot":"","sources":["../src/teamUtils.ts"],"names":[],"mappings":"AAOA,MAAM,MAAM,MAAM,GAAG,GAAG,GAAG,GAAG,CAAA;AAE9B,wBAAgB,MAAM,CAAC,SAAS,EAAE,MAAM,EAAE,EAAE,aAAa,EAAE,MAAM,GAAG,MAAM,CAEzE;AAED,wBAAgB,WAAW,CAAC,SAAS,EAAE,MAAM,EAAE,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CAEvE"}

package/dist/teamUtils.js

@@ -0,0 +1,13 @@
+// Seat-parity team assignment for a 4-seat, 2-team game where seats
+// alternate turn by turn and every other seat shares a team (seats 0/2 vs.
+// seats 1/3) — mirrors the backend's TeamAssignment
+// (platform-domain/.../model/TeamAssignment.kt) exactly. Any board for a
+// game type with GameTypeMetadataView.teamPlay === true can use this
+// instead of re-deriving team membership from turnOrder itself.
+export function teamOf(turnOrder, participantId) {
+    return turnOrder.indexOf(participantId) % 2 === 0 ? '1' : '2';
+}
+export function teamMembers(turnOrder, team) {
+    return turnOrder.filter((_, idx) => (idx % 2 === 0) === (team === '1'));
+}
+//# sourceMappingURL=teamUtils.js.map

package/dist/teamUtils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"teamUtils.js","sourceRoot":"","sources":["../src/teamUtils.ts"],"names":[],"mappings":"AAAA,oEAAoE;AACpE,2EAA2E;AAC3E,oDAAoD;AACpD,yEAAyE;AACzE,qEAAqE;AACrE,gEAAgE;AAIhE,MAAM,UAAU,MAAM,CAAC,SAAmB,EAAE,aAAqB;IAC/D,OAAO,SAAS,CAAC,OAAO,CAAC,aAAa,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG,CAAA;AAC/D,CAAC;AAED,MAAM,UAAU,WAAW,CAAC,SAAmB,EAAE,IAAY;IAC3D,OAAO,SAAS,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,GAAG,EAAE,EAAE,CAAC,CAAC,GAAG,GAAG,CAAC,KAAK,CAAC,CAAC,KAAK,CAAC,IAAI,KAAK,GAAG,CAAC,CAAC,CAAA;AACzE,CAAC"}

package/dist/turnClock.d.ts

@@ -0,0 +1,62 @@
+/** TurnClock.toMap(), as it arrives in a board's pluginState. */
+export interface TurnClockState {
+    mode: 'count-up' | 'per-turn' | 'game-clock';
+    turnLimitMs: number;
+    poolMs: number;
+    incrementMs: number;
+    usedMs: Record<string, number>;
+    runningFor: string | null;
+    startedAt: number | null;
+    turnLog: {
+        participantId: string;
+        ms: number;
+    }[];
+}
+/** The current time as the server sees it, for reading a clock against.
+ *  Re-renders once a second while [running], so a live clock keeps moving
+ *  between polls, and sits idle whenever nobody's turn is started, which
+ *  in an async game is most of the time.
+ *
+ *  Corrected by `serverNow`, a stamp the engine puts in its view: the
+ *  difference from this browser's clock, measured as the view arrives, is
+ *  added to every reading. A phone whose clock is a few seconds out then
+ *  neither fires a timeout the server will refuse nor sits past one it
+ *  would accept. The measurement absorbs the response's own latency too,
+ *  which is close enough for a clock shown to the second. */
+export declare function useClockNow(serverNow: number | undefined, running: boolean): number;
+/** m:ss, h:mm:ss past an hour, and a leading minus once a count-down
+ *  clock is overrun (a game clock plays on into overtime). */
+export declare function formatClock(ms: number): string;
+/** Time spent, including the turn in progress if it is theirs. */
+export declare function liveUsedMs(clock: TurnClockState, participantId: string, now: number): number;
+/** Mirrors TurnClock.remainingMs: the rest of this turn (per-turn), the
+ *  rest of the game budget (game-clock), negative once overrun; null for
+ *  count-up, which has no limit. */
+export declare function remainingMs(clock: TurnClockState, participantId: string, now: number): number | null;
+/** What to show for one participant: time left under a count-down mode,
+ *  time used under count-up. */
+export declare function clockReading(clock: TurnClockState, participantId: string, now: number): {
+    ms: number;
+    countingDown: boolean;
+    overrun: boolean;
+    ticking: boolean;
+};
+/** Sends [onTimeout] once when [participantId]'s own count-down clock
+ *  reaches zero, for the modes listed in [firesOn] -- what running out
+ *  means is the game's call, so which modes have a timeout move at all is
+ *  too. It has to be the player's own board that asks: a timeout is an
+ *  ordinary turn-gated move, and only the player to move can submit one.
+ *  A player who walked away mid-turn has it land when they come back,
+ *  since their clock kept running. The server re-checks the clock and
+ *  refuses an early one, in which case this asks again on a later tick
+ *  rather than wedging. [now] comes from useClockNow. */
+export declare function useClockTimeout({ clock, participantId, active, firesOn, now, onTimeout, }: {
+    clock: TurnClockState | null | undefined;
+    participantId: string;
+    /** False for anyone who isn't the player to move, or once the game is over. */
+    active: boolean;
+    firesOn: TurnClockState['mode'][];
+    now: number;
+    onTimeout: () => Promise<unknown>;
+}): void;
+//# sourceMappingURL=turnClock.d.ts.map

package/dist/turnClock.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"turnClock.d.ts","sourceRoot":"","sources":["../src/turnClock.ts"],"names":[],"mappings":"AASA,iEAAiE;AACjE,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,UAAU,GAAG,UAAU,GAAG,YAAY,CAAA;IAC5C,WAAW,EAAE,MAAM,CAAA;IACnB,MAAM,EAAE,MAAM,CAAA;IACd,WAAW,EAAE,MAAM,CAAA;IACnB,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IAC9B,UAAU,EAAE,MAAM,GAAG,IAAI,CAAA;IACzB,SAAS,EAAE,MAAM,GAAG,IAAI,CAAA;IACxB,OAAO,EAAE;QAAE,aAAa,EAAE,MAAM,CAAC;QAAC,EAAE,EAAE,MAAM,CAAA;KAAE,EAAE,CAAA;CACjD;AAED;;;;;;;;;;6DAU6D;AAC7D,wBAAgB,WAAW,CAAC,SAAS,EAAE,MAAM,GAAG,SAAS,EAAE,OAAO,EAAE,OAAO,GAAG,MAAM,CAgBnF;AAED;8DAC8D;AAC9D,wBAAgB,WAAW,CAAC,EAAE,EAAE,MAAM,GAAG,MAAM,CAQ9C;AAMD,kEAAkE;AAClE,wBAAgB,UAAU,CAAC,KAAK,EAAE,cAAc,EAAE,aAAa,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,CAE5F;AAED;;oCAEoC;AACpC,wBAAgB,WAAW,CAAC,KAAK,EAAE,cAAc,EAAE,aAAa,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAWpG;AAED;gCACgC;AAChC,wBAAgB,YAAY,CAAC,KAAK,EAAE,cAAc,EAAE,aAAa,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM;;;;;EAQrF;AAED;;;;;;;;yDAQyD;AACzD,wBAAgB,eAAe,CAAC,EAC9B,KAAK,EACL,aAAa,EACb,MAAM,EACN,OAAO,EACP,GAAG,EACH,SAAS,GACV,EAAE;IACD,KAAK,EAAE,cAAc,GAAG,IAAI,GAAG,SAAS,CAAA;IACxC,aAAa,EAAE,MAAM,CAAA;IACrB,+EAA+E;IAC/E,MAAM,EAAE,OAAO,CAAA;IACf,OAAO,EAAE,cAAc,CAAC,MAAM,CAAC,EAAE,CAAA;IACjC,GAAG,EAAE,MAAM,CAAA;IACX,SAAS,EAAE,MAAM,OAAO,CAAC,OAAO,CAAC,CAAA;CAClC,GAAG,IAAI,CAeP"}

package/dist/turnClock.js

@@ -0,0 +1,101 @@
+import { useEffect, useRef, useState } from 'react';
+/** The current time as the server sees it, for reading a clock against.
+ *  Re-renders once a second while [running], so a live clock keeps moving
+ *  between polls, and sits idle whenever nobody's turn is started, which
+ *  in an async game is most of the time.
+ *
+ *  Corrected by `serverNow`, a stamp the engine puts in its view: the
+ *  difference from this browser's clock, measured as the view arrives, is
+ *  added to every reading. A phone whose clock is a few seconds out then
+ *  neither fires a timeout the server will refuse nor sits past one it
+ *  would accept. The measurement absorbs the response's own latency too,
+ *  which is close enough for a clock shown to the second. */
+export function useClockNow(serverNow, running) {
+    const offset = useRef({ ms: 0 });
+    const [now, setNow] = useState(() => Date.now());
+    useEffect(() => {
+        if (serverNow != null && offset.current.stamp !== serverNow) {
+            offset.current = { stamp: serverNow, ms: serverNow - Date.now() };
+        }
+        const tick = () => setNow(Date.now() + offset.current.ms);
+        const first = setTimeout(tick, 0);
+        const every = running ? setInterval(tick, 1000) : undefined;
+        return () => {
+            clearTimeout(first);
+            if (every)
+                clearInterval(every);
+        };
+    }, [serverNow, running]);
+    return now;
+}
+/** m:ss, h:mm:ss past an hour, and a leading minus once a count-down
+ *  clock is overrun (a game clock plays on into overtime). */
+export function formatClock(ms) {
+    const sign = ms < 0 ? '-' : '';
+    const total = Math.floor(Math.abs(ms) / 1000);
+    const hours = Math.floor(total / 3600);
+    const mins = Math.floor((total % 3600) / 60);
+    const secs = total % 60;
+    const mm = hours > 0 ? String(mins).padStart(2, '0') : String(mins);
+    return `${sign}${hours > 0 ? `${hours}:` : ''}${mm}:${String(secs).padStart(2, '0')}`;
+}
+function currentTurnMs(clock, participantId, now) {
+    return clock.runningFor === participantId && clock.startedAt != null ? Math.max(0, now - clock.startedAt) : 0;
+}
+/** Time spent, including the turn in progress if it is theirs. */
+export function liveUsedMs(clock, participantId, now) {
+    return (clock.usedMs[participantId] ?? 0) + currentTurnMs(clock, participantId, now);
+}
+/** Mirrors TurnClock.remainingMs: the rest of this turn (per-turn), the
+ *  rest of the game budget (game-clock), negative once overrun; null for
+ *  count-up, which has no limit. */
+export function remainingMs(clock, participantId, now) {
+    switch (clock.mode) {
+        case 'per-turn':
+            return clock.turnLimitMs - currentTurnMs(clock, participantId, now);
+        case 'game-clock': {
+            const completed = clock.turnLog.filter(t => t.participantId === participantId).length;
+            return clock.poolMs + clock.incrementMs * completed - liveUsedMs(clock, participantId, now);
+        }
+        default:
+            return null;
+    }
+}
+/** What to show for one participant: time left under a count-down mode,
+ *  time used under count-up. */
+export function clockReading(clock, participantId, now) {
+    const left = remainingMs(clock, participantId, now);
+    return {
+        ms: left ?? liveUsedMs(clock, participantId, now),
+        countingDown: left != null,
+        overrun: left != null && left <= 0,
+        ticking: clock.runningFor === participantId && clock.startedAt != null,
+    };
+}
+/** Sends [onTimeout] once when [participantId]'s own count-down clock
+ *  reaches zero, for the modes listed in [firesOn] -- what running out
+ *  means is the game's call, so which modes have a timeout move at all is
+ *  too. It has to be the player's own board that asks: a timeout is an
+ *  ordinary turn-gated move, and only the player to move can submit one.
+ *  A player who walked away mid-turn has it land when they come back,
+ *  since their clock kept running. The server re-checks the clock and
+ *  refuses an early one, in which case this asks again on a later tick
+ *  rather than wedging. [now] comes from useClockNow. */
+export function useClockTimeout({ clock, participantId, active, firesOn, now, onTimeout, }) {
+    const watching = !!clock && active && firesOn.includes(clock.mode) && clock.runningFor === participantId;
+    const left = watching ? remainingMs(clock, participantId, now) : null;
+    const out = left != null && left <= 0;
+    // Which turn a timeout was already sent for, keyed by its start time,
+    // so each turn asks once and a new turn can time out again.
+    const firedFor = useRef(null);
+    const startedAt = clock?.startedAt ?? null;
+    useEffect(() => {
+        if (!out || startedAt == null || firedFor.current === startedAt)
+            return;
+        firedFor.current = startedAt;
+        onTimeout().catch(() => {
+            firedFor.current = null;
+        });
+    }, [out, startedAt, now, onTimeout]);
+}
+//# sourceMappingURL=turnClock.js.map

package/dist/turnClock.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"turnClock.js","sourceRoot":"","sources":["../src/turnClock.ts"],"names":[],"mappings":"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"}

package/dist/turnUtils.d.ts

@@ -0,0 +1,21 @@
+export interface TurnState {
+    lifecycle: string;
+    currentTurnParticipantId: string | null;
+    awaitingParticipantIds?: string[];
+    participants: string[];
+}
+/** Whether this participant may make an ordinary move -- the turn holder.
+ *  A simultaneous-phase choice is gated by the board's own phase state
+ *  instead; for "is the game waiting on me", use computeIsAwaiting. */
+export declare function computeIsMyTurn(gameView: TurnState, myParticipantId: string): boolean;
+/** Whether the game is waiting on this participant to act -- the turn
+ *  holder, or anyone yet to submit during a simultaneous phase (a
+ *  five-card selection, a fleet placement), which may not include the
+ *  turn holder at all. What "your turn" should mean to a person. */
+export declare function computeIsAwaiting(gameView: TurnState, participantId: string): boolean;
+/** True once a game is loaded read-only by a viewer who isn't one of its
+ *  participants (spectator mode) — the viewer's own id never appears in
+ *  `participants`, so every "am I white/red/X" ternary in a board falls
+ *  through to its else-branch by default unless it checks this first. */
+export declare function computeIsSpectator(gameView: TurnState, myParticipantId: string): boolean;
+//# sourceMappingURL=turnUtils.d.ts.map

package/dist/turnUtils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"turnUtils.d.ts","sourceRoot":"","sources":["../src/turnUtils.ts"],"names":[],"mappings":"AAIA,MAAM,WAAW,SAAS;IACxB,SAAS,EAAE,MAAM,CAAA;IACjB,wBAAwB,EAAE,MAAM,GAAG,IAAI,CAAA;IAMvC,sBAAsB,CAAC,EAAE,MAAM,EAAE,CAAA;IACjC,YAAY,EAAE,MAAM,EAAE,CAAA;CACvB;AAED;;uEAEuE;AACvE,wBAAgB,eAAe,CAAC,QAAQ,EAAE,SAAS,EAAE,eAAe,EAAE,MAAM,GAAG,OAAO,CAErF;AAED;;;oEAGoE;AACpE,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,SAAS,EAAE,aAAa,EAAE,MAAM,GAAG,OAAO,CAIrF;AAED;;;yEAGyE;AACzE,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,SAAS,EAAE,eAAe,EAAE,MAAM,GAAG,OAAO,CAExF"}

package/dist/turnUtils.js

@@ -0,0 +1,24 @@
+/** Whether this participant may make an ordinary move -- the turn holder.
+ *  A simultaneous-phase choice is gated by the board's own phase state
+ *  instead; for "is the game waiting on me", use computeIsAwaiting. */
+export function computeIsMyTurn(gameView, myParticipantId) {
+    return gameView.lifecycle === 'ACTIVE' && gameView.currentTurnParticipantId === myParticipantId;
+}
+/** Whether the game is waiting on this participant to act -- the turn
+ *  holder, or anyone yet to submit during a simultaneous phase (a
+ *  five-card selection, a fleet placement), which may not include the
+ *  turn holder at all. What "your turn" should mean to a person. */
+export function computeIsAwaiting(gameView, participantId) {
+    if (gameView.lifecycle !== 'ACTIVE')
+        return false;
+    const awaiting = gameView.awaitingParticipantIds;
+    return awaiting ? awaiting.includes(participantId) : gameView.currentTurnParticipantId === participantId;
+}
+/** True once a game is loaded read-only by a viewer who isn't one of its
+ *  participants (spectator mode) — the viewer's own id never appears in
+ *  `participants`, so every "am I white/red/X" ternary in a board falls
+ *  through to its else-branch by default unless it checks this first. */
+export function computeIsSpectator(gameView, myParticipantId) {
+    return !gameView.participants.includes(myParticipantId);
+}
+//# sourceMappingURL=turnUtils.js.map

package/dist/turnUtils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"turnUtils.js","sourceRoot":"","sources":["../src/turnUtils.ts"],"names":[],"mappings":"AAgBA;;uEAEuE;AACvE,MAAM,UAAU,eAAe,CAAC,QAAmB,EAAE,eAAuB;IAC1E,OAAO,QAAQ,CAAC,SAAS,KAAK,QAAQ,IAAI,QAAQ,CAAC,wBAAwB,KAAK,eAAe,CAAA;AACjG,CAAC;AAED;;;oEAGoE;AACpE,MAAM,UAAU,iBAAiB,CAAC,QAAmB,EAAE,aAAqB;IAC1E,IAAI,QAAQ,CAAC,SAAS,KAAK,QAAQ;QAAE,OAAO,KAAK,CAAA;IACjD,MAAM,QAAQ,GAAG,QAAQ,CAAC,sBAAsB,CAAA;IAChD,OAAO,QAAQ,CAAC,CAAC,CAAC,QAAQ,CAAC,QAAQ,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,wBAAwB,KAAK,aAAa,CAAA;AAC1G,CAAC;AAED;;;yEAGyE;AACzE,MAAM,UAAU,kBAAkB,CAAC,QAAmB,EAAE,eAAuB;IAC7E,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAC,QAAQ,CAAC,eAAe,CAAC,CAAA;AACzD,CAAC"}

package/dist/useCanvasCamera.d.ts

@@ -0,0 +1,54 @@
+import { type RefObject } from 'react';
+export interface Vec2 {
+    x: number;
+    y: number;
+}
+export interface UseCanvasCameraOptions {
+    canvasRef: RefObject<HTMLCanvasElement | null>;
+    /** World-space dimensions of the whole board, in whatever units your draw code already uses (e.g. terrain width/VIEW_HEIGHT). Camera state is expressed in these same units. */
+    worldWidth: number;
+    worldHeight: number;
+    /** Floor for zoom -- 1 means "the whole board fits exactly", matching a canvas whose CSS aspect-ratio already locks to worldWidth/worldHeight (no letterboxing to derive a floor from, unlike Pocket Tactics' own viewport-relative minZoom). Pass a smaller value if your canvas's aspect ratio can differ from the world's. */
+    minZoom?: number;
+    /** Ceiling is minZoom * this multiplier. */
+    maxZoomMultiplier?: number;
+    /** Zoom the camera starts at, clamped into [minZoom, maxZoom]. Defaults
+     *  to minZoom (the whole board). Set this above minZoom for a board that
+     *  is unreadable when fully fitted -- risk-remote's world map on a phone,
+     *  where "fit everything" and "legible" are mutually exclusive -- so it
+     *  opens on a usable crop the player can still zoom out of. Read ONCE, on
+     *  the hook's first render: later changes never yank the camera out from
+     *  under someone mid-game, so a consumer whose value depends on measured
+     *  layout should mount this hook only once that measurement exists (see
+     *  that plugin's MapCanvas, split into a measuring shell and a surface
+     *  keyed on the layout it was built for). */
+    initialZoom?: number;
+    /** true only for a board whose own single-pointer interaction is tap/click, never drag -- see this file's header comment. Default false. */
+    singlePointerPan?: boolean;
+    /** Your board's own single-pointer game-interaction callbacks, in world coordinates. Never called for a pointer sequence the camera has claimed (2+ simultaneous pointers, or any single pointer at all when singlePointerPan is true). */
+    onPointerDown?: (p: Vec2, e: React.PointerEvent<HTMLCanvasElement>) => void;
+    onPointerMove?: (p: Vec2, e: React.PointerEvent<HTMLCanvasElement>) => void;
+    onPointerUp?: (p: Vec2, e: React.PointerEvent<HTMLCanvasElement>) => void;
+    onPointerCancel?: (e: React.PointerEvent<HTMLCanvasElement>) => void;
+}
+export interface CanvasCamera {
+    zoom: number;
+    /** World coordinate that appears at the canvas's own top-left corner. */
+    offsetX: number;
+    offsetY: number;
+    /** Call once per draw, right after any device-pixel-ratio ctx.setTransform -- everything drawn after this in plain world coordinates comes out correctly zoomed/panned, no draw function needs to know the camera exists. */
+    applyTransform: (ctx: CanvasRenderingContext2D) => void;
+    /** clientX/clientY (from any PointerEvent/MouseEvent/WheelEvent) -> world coordinates, accounting for the current camera. */
+    toWorld: (clientX: number, clientY: number) => Vec2;
+    /** Recenters the viewport on a world point at the *current* zoom (doesn't change zoom) -- e.g. snapping to an active unit, or following a projectile frame by frame as its replay animates. Clamped the same as any other pan. */
+    centerOn: (worldX: number, worldY: number) => void;
+    /** Spread onto your <canvas>. Wraps your own onPointerDown/Move/Up/Cancel (from the options above) with pinch/pan gesture detection. */
+    canvasProps: {
+        onPointerDown: (e: React.PointerEvent<HTMLCanvasElement>) => void;
+        onPointerMove: (e: React.PointerEvent<HTMLCanvasElement>) => void;
+        onPointerUp: (e: React.PointerEvent<HTMLCanvasElement>) => void;
+        onPointerCancel: (e: React.PointerEvent<HTMLCanvasElement>) => void;
+    };
+}
+export declare function useCanvasCamera({ canvasRef, worldWidth, worldHeight, minZoom, maxZoomMultiplier, initialZoom, singlePointerPan, onPointerDown, onPointerMove, onPointerUp, onPointerCancel, }: UseCanvasCameraOptions): CanvasCamera;
+//# sourceMappingURL=useCanvasCamera.d.ts.map

package/dist/useCanvasCamera.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useCanvasCamera.d.ts","sourceRoot":"","sources":["../src/useCanvasCamera.ts"],"names":[],"mappings":"AA8BA,OAAO,EAA+B,KAAK,SAAS,EAAE,MAAM,OAAO,CAAA;AAEnE,MAAM,WAAW,IAAI;IACnB,CAAC,EAAE,MAAM,CAAA;IACT,CAAC,EAAE,MAAM,CAAA;CACV;AAED,MAAM,WAAW,sBAAsB;IACrC,SAAS,EAAE,SAAS,CAAC,iBAAiB,GAAG,IAAI,CAAC,CAAA;IAC9C,gLAAgL;IAChL,UAAU,EAAE,MAAM,CAAA;IAClB,WAAW,EAAE,MAAM,CAAA;IACnB,iUAAiU;IACjU,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,4CAA4C;IAC5C,iBAAiB,CAAC,EAAE,MAAM,CAAA;IAC1B;;;;;;;;;iDAS6C;IAC7C,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,4IAA4I;IAC5I,gBAAgB,CAAC,EAAE,OAAO,CAAA;IAC1B,2OAA2O;IAC3O,aAAa,CAAC,EAAE,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,KAAK,CAAC,YAAY,CAAC,iBAAiB,CAAC,KAAK,IAAI,CAAA;IAC3E,aAAa,CAAC,EAAE,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,KAAK,CAAC,YAAY,CAAC,iBAAiB,CAAC,KAAK,IAAI,CAAA;IAC3E,WAAW,CAAC,EAAE,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,KAAK,CAAC,YAAY,CAAC,iBAAiB,CAAC,KAAK,IAAI,CAAA;IACzE,eAAe,CAAC,EAAE,CAAC,CAAC,EAAE,KAAK,CAAC,YAAY,CAAC,iBAAiB,CAAC,KAAK,IAAI,CAAA;CACrE;AAED,MAAM,WAAW,YAAY;IAC3B,IAAI,EAAE,MAAM,CAAA;IACZ,yEAAyE;IACzE,OAAO,EAAE,MAAM,CAAA;IACf,OAAO,EAAE,MAAM,CAAA;IACf,6NAA6N;IAC7N,cAAc,EAAE,CAAC,GAAG,EAAE,wBAAwB,KAAK,IAAI,CAAA;IACvD,6HAA6H;IAC7H,OAAO,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,KAAK,IAAI,CAAA;IACnD,kOAAkO;IAClO,QAAQ,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,KAAK,IAAI,CAAA;IAClD,wIAAwI;IACxI,WAAW,EAAE;QACX,aAAa,EAAE,CAAC,CAAC,EAAE,KAAK,CAAC,YAAY,CAAC,iBAAiB,CAAC,KAAK,IAAI,CAAA;QACjE,aAAa,EAAE,CAAC,CAAC,EAAE,KAAK,CAAC,YAAY,CAAC,iBAAiB,CAAC,KAAK,IAAI,CAAA;QACjE,WAAW,EAAE,CAAC,CAAC,EAAE,KAAK,CAAC,YAAY,CAAC,iBAAiB,CAAC,KAAK,IAAI,CAAA;QAC/D,eAAe,EAAE,CAAC,CAAC,EAAE,KAAK,CAAC,YAAY,CAAC,iBAAiB,CAAC,KAAK,IAAI,CAAA;KACpE,CAAA;CACF;AAMD,wBAAgB,eAAe,CAAC,EAC9B,SAAS,EACT,UAAU,EACV,WAAW,EACX,OAAW,EACX,iBAAqB,EACrB,WAAW,EACX,gBAAwB,EACxB,aAAa,EACb,aAAa,EACb,WAAW,EACX,eAAe,GAChB,EAAE,sBAAsB,GAAG,YAAY,CA2LvC"}

package/dist/useCanvasCamera.js

@@ -0,0 +1,218 @@
+// Pinch-to-zoom + wheel-to-zoom + two-finger-pan for a `<canvas>`-rendered
+// game board, factored out of zephyrs-remote/frontend after pocket-tactics-
+// remote (a different repo, PixiJS-based) and zephyrs-remote (raw Canvas2D)
+// independently solved the exact same "zoom and pan a canvas inside a
+// ShadowMount" problem. Renderer-agnostic on purpose: this hook only
+// tracks pointer/wheel gestures and produces a zoom/offset camera state,
+// via applyTransform's `ctx.scale`+`ctx.translate` convenience for a raw
+// Canvas2D board (Zephyrs' case) or by reading `.zoom`/`.offsetX`/
+// `.offsetY` directly and driving a Pixi Container's own scale/position
+// instead (Pocket Tactics' case) -- it never touches the DOM/canvas
+// beyond attaching listeners and (optionally) calling ctx methods you
+// hand it.
+//
+// Part of @anweather/plugin-board-kit: a consumer imports it from the
+// package, whose `react` is a peer dependency resolved from the
+// consumer's own node_modules -- one React instance per bundle. (This
+// file used to be vendored by a shell script for exactly that reason: a
+// plain relative import out of one project into another resolved `react`
+// against whichever node_modules sat above the file, built cleanly, and
+// then threw "Cannot read properties of null (reading 'useState')" at
+// runtime from two React instances in one bundle.)
+//
+// Why this can't just be "one finger pans, like Pocket Tactics does": that
+// design assumes single-pointer drag is free for the camera to claim.
+// It isn't, the moment a game's own primary interaction is also a
+// single-pointer drag (Zephyrs' drag-to-aim) -- see singlePointerPan
+// below. Default to false; only set it true for a board whose own
+// pointerDown/Move/Up callbacks are tap/click-only (Pocket Tactics'
+// select/move/attack are all taps), never for one that uses drag itself.
+import { useEffect, useRef, useState } from 'react';
+function clamp(value, min, max) {
+    return Math.min(max, Math.max(min, value));
+}
+export function useCanvasCamera({ canvasRef, worldWidth, worldHeight, minZoom = 1, maxZoomMultiplier = 3, initialZoom, singlePointerPan = false, onPointerDown, onPointerMove, onPointerUp, onPointerCancel, }) {
+    const maxZoom = minZoom * maxZoomMultiplier;
+    // Math.max guards the degenerate maxZoomMultiplier < 1 (a ceiling below
+    // the floor): without it, clamp would return the ceiling and this would
+    // be the one input shape whose starting zoom changed when initialZoom was
+    // added. No consumer configures that, but it costs nothing to keep this
+    // strictly identical to the old `useState(minZoom)` for every caller that
+    // doesn't pass initialZoom.
+    const [zoom, setZoom] = useState(() => clamp(initialZoom ?? minZoom, minZoom, Math.max(minZoom, minZoom * maxZoomMultiplier)));
+    const [offsetX, setOffsetX] = useState(0);
+    const [offsetY, setOffsetY] = useState(0);
+    // Gesture bookkeeping -- refs, not state, since none of this needs to
+    // trigger a re-render on its own (zoom/offsetX/offsetY already do).
+    const pointersRef = useRef(new Map());
+    const pinchRef = useRef(null);
+    // Set the moment a second pointer joins (or, with singlePointerPan, the
+    // moment any pointer goes down) -- cleared only once every pointer has
+    // lifted, so a finger left over from a pinch can't suddenly start a
+    // fresh single-pointer game gesture from wherever it's sitting.
+    const claimedByGestureRef = useRef(false);
+    // Read inside gesture handlers via refs, not the zoom/offsetX/offsetY
+    // state directly -- pointerdown/move fire faster than React re-renders
+    // commit, so reading state there can see a stale value mid-gesture.
+    const zoomRef = useRef(zoom);
+    const offsetRef = useRef({ x: offsetX, y: offsetY });
+    zoomRef.current = zoom;
+    offsetRef.current = { x: offsetX, y: offsetY };
+    function clampOffset(offset, atZoom, dimension) {
+        const maxOffset = Math.max(0, dimension - dimension / atZoom);
+        return clamp(offset, 0, maxOffset);
+    }
+    function toView(clientX, clientY) {
+        const canvas = canvasRef.current;
+        const rect = canvas.getBoundingClientRect();
+        return {
+            x: ((clientX - rect.left) * worldWidth) / rect.width,
+            y: ((clientY - rect.top) * worldHeight) / rect.height,
+        };
+    }
+    function toWorld(clientX, clientY) {
+        const v = toView(clientX, clientY);
+        return { x: v.x / zoomRef.current + offsetRef.current.x, y: v.y / zoomRef.current + offsetRef.current.y };
+    }
+    /** Rescales around a fixed view-space point by `factor`, clamped to [minZoom, maxZoom], keeping that point visually fixed. */
+    function zoomAround(viewX, viewY, factor) {
+        const prevZoom = zoomRef.current;
+        const newZoom = clamp(prevZoom * factor, minZoom, maxZoom);
+        const anchorWorldX = viewX / prevZoom + offsetRef.current.x;
+        const anchorWorldY = viewY / prevZoom + offsetRef.current.y;
+        setZoom(newZoom);
+        setOffsetX(clampOffset(anchorWorldX - viewX / newZoom, newZoom, worldWidth));
+        setOffsetY(clampOffset(anchorWorldY - viewY / newZoom, newZoom, worldHeight));
+    }
+    function centerOn(worldX, worldY) {
+        const zoomNow = zoomRef.current;
+        setOffsetX(clampOffset(worldX - worldWidth / zoomNow / 2, zoomNow, worldWidth));
+        setOffsetY(clampOffset(worldY - worldHeight / zoomNow / 2, zoomNow, worldHeight));
+    }
+    // Native (non-passive) wheel listener, desktop-only zoom (mouse wheel/
+    // trackpad) -- React's synthetic onWheel is passive by default, so
+    // e.preventDefault() inside it silently no-ops in some browsers and the
+    // page scrolls instead of the board zooming. Touch is the primary input
+    // this hook is designed for (see singlePointerPan below): pinch zooms,
+    // drag pans, both via real multi-touch PointerEvents below, nothing to
+    // do with wheel at all.
+    useEffect(() => {
+        const canvas = canvasRef.current;
+        if (!canvas)
+            return;
+        const handleWheel = (e) => {
+            e.preventDefault();
+            const view = toView(e.clientX, e.clientY);
+            zoomAround(view.x, view.y, e.deltaY > 0 ? 0.9 : 1.1);
+        };
+        canvas.addEventListener('wheel', handleWheel, { passive: false });
+        return () => canvas.removeEventListener('wheel', handleWheel);
+        // eslint-disable-next-line react-hooks/exhaustive-deps -- zoomAround/toView read current state via refs, not closed-over values
+    }, [canvasRef, worldWidth, worldHeight]);
+    function handlePointerDown(e) {
+        // Keep receiving move/up for this pointer even if it's dragged outside
+        // the canvas (a pinch finger sliding off the element, or a drag past
+        // the edge to aim a big shot). Wrapped: some browsers throw for a
+        // pointerId their own internal active-pointer tracking doesn't
+        // recognize (seen with synthetically dispatched PointerEvents in
+        // tests) -- losing capture only risks a truncated drag, not a crash.
+        try {
+            e.currentTarget.setPointerCapture(e.pointerId);
+        }
+        catch {
+            // Non-fatal -- see comment above.
+        }
+        pointersRef.current.set(e.pointerId, { x: e.clientX, y: e.clientY });
+        if (pointersRef.current.size === 2) {
+            if (!claimedByGestureRef.current)
+                onPointerCancel?.(e);
+            claimedByGestureRef.current = true;
+            const [a, b] = [...pointersRef.current.values()];
+            const startDist = Math.hypot(b.x - a.x, b.y - a.y);
+            const mid = toView((a.x + b.x) / 2, (a.y + b.y) / 2);
+            pinchRef.current = {
+                startDist,
+                startZoom: zoomRef.current,
+                anchorWorldX: mid.x / zoomRef.current + offsetRef.current.x,
+                anchorWorldY: mid.y / zoomRef.current + offsetRef.current.y,
+            };
+        }
+        else if (pointersRef.current.size === 1) {
+            if (singlePointerPan) {
+                claimedByGestureRef.current = true;
+                const mid = toView(e.clientX, e.clientY);
+                pinchRef.current = {
+                    startDist: 0,
+                    startZoom: zoomRef.current,
+                    anchorWorldX: mid.x / zoomRef.current + offsetRef.current.x,
+                    anchorWorldY: mid.y / zoomRef.current + offsetRef.current.y,
+                };
+            }
+            else {
+                onPointerDown?.(toWorld(e.clientX, e.clientY), e);
+            }
+        }
+    }
+    function handlePointerMove(e) {
+        if (!pointersRef.current.has(e.pointerId))
+            return;
+        pointersRef.current.set(e.pointerId, { x: e.clientX, y: e.clientY });
+        if (pointersRef.current.size >= 2 && pinchRef.current) {
+            const [a, b] = [...pointersRef.current.values()];
+            const dist = Math.hypot(b.x - a.x, b.y - a.y);
+            const mid = toView((a.x + b.x) / 2, (a.y + b.y) / 2);
+            const { startDist, startZoom, anchorWorldX, anchorWorldY } = pinchRef.current;
+            const newZoom = clamp(startZoom * (dist / Math.max(startDist, 1)), minZoom, maxZoom);
+            setZoom(newZoom);
+            setOffsetX(clampOffset(anchorWorldX - mid.x / newZoom, newZoom, worldWidth));
+            setOffsetY(clampOffset(anchorWorldY - mid.y / newZoom, newZoom, worldHeight));
+        }
+        else if (pointersRef.current.size === 1 && singlePointerPan && pinchRef.current) {
+            // Pure pan (zoom unchanged) anchored at the single point, same
+            // anchor math as the pinch branch with a fixed zoom.
+            const mid = toView(e.clientX, e.clientY);
+            const { startZoom, anchorWorldX, anchorWorldY } = pinchRef.current;
+            setOffsetX(clampOffset(anchorWorldX - mid.x / startZoom, startZoom, worldWidth));
+            setOffsetY(clampOffset(anchorWorldY - mid.y / startZoom, startZoom, worldHeight));
+        }
+        else if (pointersRef.current.size === 1 && !claimedByGestureRef.current) {
+            onPointerMove?.(toWorld(e.clientX, e.clientY), e);
+        }
+    }
+    function endPointer(e, kind) {
+        const wasTracked = pointersRef.current.has(e.pointerId);
+        pointersRef.current.delete(e.pointerId);
+        if (pointersRef.current.size < 2)
+            pinchRef.current = null;
+        if (pointersRef.current.size === 0) {
+            // Only deliver a genuine single-pointer up/cancel to the game-logic
+            // callbacks -- once a gesture has claimed this touch sequence, its
+            // release shouldn't also fire a game action.
+            if (wasTracked && !claimedByGestureRef.current) {
+                if (kind === 'up')
+                    onPointerUp?.(toWorld(e.clientX, e.clientY), e);
+                else
+                    onPointerCancel?.(e);
+            }
+            claimedByGestureRef.current = false;
+        }
+    }
+    return {
+        zoom,
+        offsetX,
+        offsetY,
+        applyTransform(ctx) {
+            ctx.scale(zoom, zoom);
+            ctx.translate(-offsetX, -offsetY);
+        },
+        toWorld,
+        centerOn,
+        canvasProps: {
+            onPointerDown: handlePointerDown,
+            onPointerMove: handlePointerMove,
+            onPointerUp: (e) => endPointer(e, 'up'),
+            onPointerCancel: (e) => endPointer(e, 'cancel'),
+        },
+    };
+}
+//# sourceMappingURL=useCanvasCamera.js.map

package/dist/useCanvasCamera.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useCanvasCamera.js","sourceRoot":"","sources":["../src/useCanvasCamera.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "@anweather/plugin-board-kit",
+  "version": "1.7.0",
+  "description": "Board-UI primitives for a web-boardgame-platform game board: the mount/update/unmount handle a remote plugin's bundle exports, BoardShell/TurnIdentity layout, turn/spectator/team helpers, the TurnClock display half, and the pinch/wheel canvas camera. React is a peer dependency, so a plugin's bundle carries exactly one React.",
+  "license": "MIT",
+  "type": "module",
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist/**"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "clean": "rm -rf dist",
+    "prepack": "npm run clean && npm run build",
+    "test": "tsx --test test/*.test.ts",
+    "typecheck": "tsc -p tsconfig.test.json"
+  },
+  "peerDependencies": {
+    "react": "^19.0.0",
+    "react-dom": "^19.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.20.4",
+    "@types/react": "^19.2.14",
+    "@types/react-dom": "^19.2.3",
+    "react": "^19.2.6",
+    "react-dom": "^19.2.6",
+    "tsx": "^4.19.2",
+    "typescript": "~5.8.3"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}