@rydr/game-sdk 1.7.0

package/dist/protocol/messages.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=messages.js.map

package/dist/protocol/messages.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"messages.js","sourceRoot":"","sources":["../../src/protocol/messages.ts"],"names":[],"mappings":""}

package/dist/protocol/replays.d.ts

@@ -0,0 +1,67 @@
+/**
+ * Replay/ghost types — the frame contract, the decoded body, the derived display meta, and the
+ * `session.getReplays(boardId)` result shape.
+ *
+ * A replay is an array of {@link ReplayFrame} the game saves with {@link PlatformSession.saveReplay}
+ * keyed by the session's `runId`. The SDK encodes the frames into a compressed blob and derives a
+ * {@link ReplayMeta} summary stored alongside it. Replays align to leaderboard standings through the
+ * shared `runId`: the `boards` party stamps `runId` on each entry, so "the ghosts for the top-N" is
+ * the leaderboard's top-N entries' replays. `getReplays` composes that — it reads the leaderboard
+ * page, then fetches each ranked entry's blob + meta — returning one {@link ReplayRef} per ranked
+ * entry; decode a specific one's frames with `getReplay`/`decodeReplay`.
+ */
+/**
+ * One replay frame. A replay is an array of these — the time-series a game interpolates over to
+ * render a ghost. `t` and `power` are MANDATORY and platform-readable (so the timeline + power of
+ * any replay are legible without understanding the game); `customData` is the game's own opaque
+ * per-frame payload. Frames need not be evenly spaced — timing lives entirely in `t`, so there is
+ * no global sample rate / frame count to drift out of sync.
+ */
+export interface ReplayFrame {
+    /** Elapsed time from replay start, in ms. */
+    t: number;
+    /** Instantaneous power, in watts. */
+    power: number;
+    /** Game-specific per-frame payload (position, lean, animation…). Opaque to the platform. */
+    customData?: unknown;
+}
+/**
+ * The decoded body of a replay blob: a versioned array of {@link ReplayFrame}. `version` lets a
+ * game evolve its frame/`customData` shape and still recognise (or reject) older replays.
+ * Produced/consumed by `encodeReplay`/`decodeReplay`.
+ */
+export interface ReplayBody {
+    version: number;
+    frames: ReplayFrame[];
+}
+/**
+ * A small, platform-visible summary of a replay, DERIVED from its frames at save time. Lets a
+ * ghost/replay list render (length + power) without fetching and decompressing every blob.
+ *
+ * Who/score/when are intentionally NOT here — they live on the leaderboard entry sharing the same
+ * `runId` (`displayName`/`value`/`ts`). Meta only adds what the timeline itself knows.
+ */
+export interface ReplayMeta {
+    /** Total replay length in ms (the last frame's `t`). */
+    durationMs: number;
+    /** Mean of every frame's `power`, in watts. */
+    avgPower: number;
+    /** Peak frame `power`, in watts. */
+    maxPower: number;
+}
+/** One ranked leaderboard entry paired with its stored replay (if any). */
+export interface ReplayRef {
+    /** The run this replay/entry came from. */
+    runId: string;
+    /** 1-based rank on the board this came from. */
+    rank: number;
+    /** The entry's display name (for labelling the ghost). */
+    displayName: string;
+    /** The entry's board value (e.g. lap time in ms). */
+    value: number;
+    /** The opaque replay blob (base64), or `null` if no replay was stored for this run. */
+    blob: string | null;
+    /** Derived display summary of the replay, or `null` when no replay/meta was stored. */
+    meta: ReplayMeta | null;
+}
+//# sourceMappingURL=replays.d.ts.map

package/dist/protocol/replays.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"replays.d.ts","sourceRoot":"","sources":["../../src/protocol/replays.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH;;;;;;GAMG;AACH,MAAM,WAAW,WAAW;IAC1B,6CAA6C;IAC7C,CAAC,EAAE,MAAM,CAAC;IACV,qCAAqC;IACrC,KAAK,EAAE,MAAM,CAAC;IACd,4FAA4F;IAC5F,UAAU,CAAC,EAAE,OAAO,CAAC;CACtB;AAED;;;;GAIG;AACH,MAAM,WAAW,UAAU;IACzB,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,WAAW,EAAE,CAAC;CACvB;AAED;;;;;;GAMG;AACH,MAAM,WAAW,UAAU;IACzB,wDAAwD;IACxD,UAAU,EAAE,MAAM,CAAC;IACnB,+CAA+C;IAC/C,QAAQ,EAAE,MAAM,CAAC;IACjB,oCAAoC;IACpC,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED,2EAA2E;AAC3E,MAAM,WAAW,SAAS;IACxB,2CAA2C;IAC3C,KAAK,EAAE,MAAM,CAAC;IACd,gDAAgD;IAChD,IAAI,EAAE,MAAM,CAAC;IACb,0DAA0D;IAC1D,WAAW,EAAE,MAAM,CAAC;IACpB,qDAAqD;IACrD,KAAK,EAAE,MAAM,CAAC;IACd,uFAAuF;IACvF,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IACpB,uFAAuF;IACvF,IAAI,EAAE,UAAU,GAAG,IAAI,CAAC;CACzB"}

package/dist/protocol/replays.js

@@ -0,0 +1,14 @@
+/**
+ * Replay/ghost types — the frame contract, the decoded body, the derived display meta, and the
+ * `session.getReplays(boardId)` result shape.
+ *
+ * A replay is an array of {@link ReplayFrame} the game saves with {@link PlatformSession.saveReplay}
+ * keyed by the session's `runId`. The SDK encodes the frames into a compressed blob and derives a
+ * {@link ReplayMeta} summary stored alongside it. Replays align to leaderboard standings through the
+ * shared `runId`: the `boards` party stamps `runId` on each entry, so "the ghosts for the top-N" is
+ * the leaderboard's top-N entries' replays. `getReplays` composes that — it reads the leaderboard
+ * page, then fetches each ranked entry's blob + meta — returning one {@link ReplayRef} per ranked
+ * entry; decode a specific one's frames with `getReplay`/`decodeReplay`.
+ */
+export {};
+//# sourceMappingURL=replays.js.map

package/dist/protocol/replays.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"replays.js","sourceRoot":"","sources":["../../src/protocol/replays.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG"}

package/dist/protocol/room.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Realtime room types — the shell-vouched fields shared by every room, kept separate from the
+ * opaque game payloads (mirrors how {@link ReplayMeta} sits beside the opaque replay blob).
+ *
+ * A room carries three kinds of traffic over one shell-owned connection:
+ * - **presence** — who's here ({@link RoomMember}); shell-stamped identity.
+ * - **telemetry** — each member's live, real hardware reading ({@link RoomTelemetry}); injected by
+ *   the shell that owns the hardware, so it can't be forged by a game. The mandatory, typed part.
+ * - **message / state** — the game's own opaque payloads (`send`/`setState`); the platform never
+ *   parses them. The blob part.
+ */
+/** A player present in a room. Identity is shell-stamped; `name` is the public display name. */
+export interface RoomMember {
+    playerId: string;
+    name?: string;
+}
+/**
+ * A trusted, live hardware reading for one room member, broadcast by that member's shell. Raw
+ * measured signals only — speed/position is a game-computed output and belongs in the opaque
+ * `send`/`state` payloads, not here. Fields are optional because a given sample may carry only
+ * some of them (e.g. an HRM update with no power).
+ */
+export interface RoomTelemetry {
+    /** The member this reading belongs to (server-stamped — never self-reported). */
+    playerId: string;
+    /** Instantaneous power, in watts. */
+    power?: number;
+    /** Pedalling cadence, in rpm. */
+    cadence?: number;
+    /** Heart rate, in bpm. */
+    heartRate?: number;
+    /** ms timestamp from the originating shell's clock. */
+    t: number;
+}
+/**
+ * A server-stamped, genre-neutral orchestration event — the "referee whistle" / match clock. A
+ * member schedules one (`room.scheduleEvent`); the server stamps it on a shared clock and broadcasts
+ * it to everyone, so all clients act on the same wall-clock instant with no host head start.
+ *
+ * The room knows nothing about what `name` means — a game's host-run orchestrator gives it meaning
+ * (a race uses `"start"`/`"grace"`/`"advance"`/`"finished"`; a match could use `"point"`/`"set"`).
+ * Timing-sensitive events carry a future `at`; clients self-schedule against their skew-corrected
+ * clock until then (the server runs no timers).
+ */
+export interface RoomEvent {
+    /** Game-defined event name. Opaque to the platform. */
+    name: string;
+    /** Game-defined opaque payload. */
+    payload: unknown;
+    /** Server-stamped wall-clock time (ms) to act on. Immediate events: ≈ broadcast time. */
+    at: number;
+    /** playerId that scheduled it (server-stamped — never the message body). */
+    from: string;
+}
+//# sourceMappingURL=room.d.ts.map

package/dist/protocol/room.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"room.d.ts","sourceRoot":"","sources":["../../src/protocol/room.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,gGAAgG;AAChG,MAAM,WAAW,UAAU;IACzB,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAED;;;;;GAKG;AACH,MAAM,WAAW,aAAa;IAC5B,iFAAiF;IACjF,QAAQ,EAAE,MAAM,CAAC;IACjB,qCAAqC;IACrC,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,iCAAiC;IACjC,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,0BAA0B;IAC1B,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,uDAAuD;IACvD,CAAC,EAAE,MAAM,CAAC;CACX;AAED;;;;;;;;;GASG;AACH,MAAM,WAAW,SAAS;IACxB,uDAAuD;IACvD,IAAI,EAAE,MAAM,CAAC;IACb,mCAAmC;IACnC,OAAO,EAAE,OAAO,CAAC;IACjB,yFAAyF;IACzF,EAAE,EAAE,MAAM,CAAC;IACX,4EAA4E;IAC5E,IAAI,EAAE,MAAM,CAAC;CACd"}

package/dist/protocol/room.js

@@ -0,0 +1,13 @@
+/**
+ * Realtime room types — the shell-vouched fields shared by every room, kept separate from the
+ * opaque game payloads (mirrors how {@link ReplayMeta} sits beside the opaque replay blob).
+ *
+ * A room carries three kinds of traffic over one shell-owned connection:
+ * - **presence** — who's here ({@link RoomMember}); shell-stamped identity.
+ * - **telemetry** — each member's live, real hardware reading ({@link RoomTelemetry}); injected by
+ *   the shell that owns the hardware, so it can't be forged by a game. The mandatory, typed part.
+ * - **message / state** — the game's own opaque payloads (`send`/`setState`); the platform never
+ *   parses them. The blob part.
+ */
+export {};
+//# sourceMappingURL=room.js.map

package/dist/protocol/room.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"room.js","sourceRoot":"","sources":["../../src/protocol/room.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG"}

package/dist/protocol/version.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Wire-protocol version of the platform↔game boundary.
+ *
+ * Bumped only for protocol-shape changes. The platform shell advertises a
+ * supported range and up-converts older messages via an adapter, so a game
+ * built against an older protocol keeps working. Evolve the protocol
+ * ADDITIVELY — never change or remove an existing message shape.
+ */
+export declare const RYDR_PROTOCOL_VERSION: 2;
+/** Semver of this SDK build. Sent in the handshake for telemetry/debugging. */
+export declare const RYDR_SDK_VERSION = "1.7.0";
+//# sourceMappingURL=version.d.ts.map

package/dist/protocol/version.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"version.d.ts","sourceRoot":"","sources":["../../src/protocol/version.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,eAAO,MAAM,qBAAqB,EAAG,CAAU,CAAC;AAEhD,+EAA+E;AAC/E,eAAO,MAAM,gBAAgB,UAAU,CAAC"}

package/dist/protocol/version.js

@@ -0,0 +1,12 @@
+/**
+ * Wire-protocol version of the platform↔game boundary.
+ *
+ * Bumped only for protocol-shape changes. The platform shell advertises a
+ * supported range and up-converts older messages via an adapter, so a game
+ * built against an older protocol keeps working. Evolve the protocol
+ * ADDITIVELY — never change or remove an existing message shape.
+ */
+export const RYDR_PROTOCOL_VERSION = 2;
+/** Semver of this SDK build. Sent in the handshake for telemetry/debugging. */
+export const RYDR_SDK_VERSION = "1.7.0";
+//# sourceMappingURL=version.js.map

package/dist/protocol/version.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"version.js","sourceRoot":"","sources":["../../src/protocol/version.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,qBAAqB,GAAG,CAAU,CAAC;AAEhD,+EAA+E;AAC/E,MAAM,CAAC,MAAM,gBAAgB,GAAG,OAAO,CAAC"}

package/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "@rydr/game-sdk",
+  "version": "1.7.0",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/bdefrenne/rydr-game-sdk.git"
+  },
+  "description": "Client SDK for building games on the RYDR indoor-cycling platform: the typed platform↔game wire protocol, a bridged hardware hook, RYDR UI components/tokens, and a local dev harness.",
+  "license": "UNLICENSED",
+  "type": "module",
+  "publishConfig": {
+    "access": "public"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "prepare": "tsc -p tsconfig.json",
+    "dev": "tsc -w -p tsconfig.json",
+    "clean": "rm -rf dist",
+    "typecheck": "tsc --noEmit -p tsconfig.json",
+    "version": "node scripts/sync-version.mjs && git add src/protocol/version.ts",
+    "postversion": "git push --follow-tags"
+  },
+  "devDependencies": {
+    "typescript": "^5.5.0"
+  }
+}