@indiegems/gem-web-sdk 10.4.0 → 11.1.0

package/docs/api/api-reference-game.md

@@ -1,6 +1,6 @@
 # The browser surface — API reference
 
-Generated from `@indiegems/gem-web-sdk/sdk` v10.4.0, the version of the package this file ships in. Every symbol below carries an explicit anchor, its `anchor` in `reference.json` beside this file.
+Generated from `@indiegems/gem-web-sdk/sdk` v11.1.0, the version of the package this file ships in. Every symbol below carries an explicit anchor, its `anchor` in `reference.json` beside this file.
 
 `@indiegems/gem-web-sdk/sdk` is the one import a game writes, wherever its code runs. `@indiegems/gem-web-sdk/game` exports exactly the symbols on this page and nothing else, for a build that wants only this half.
 
@@ -5639,15 +5639,22 @@ arcade that handles share.
 ## GemFrame.requestAvatarPicker
 
 ```ts
-requestAvatarPicker(): boolean
+requestAvatarPicker(tab?: "2d" | "3d"): boolean
 ```
 
 Ask the arcade to open its own avatar picker over your game. Nothing comes
-back: a changed portrait arrives as a new `gem.player`, through `onPlayer`.
+back: a changed portrait or 3D character arrives as a new `gem.player`,
+through `onPlayer`.
 
 Prefer `gem.openAvatarPicker`, which documents what a game does with the
 change.
 
+| Parameter | Type | Description |
+| --- | --- | --- |
+| `tab` | `"2d" \| "3d"` | Which tab to open on — `'2d'` (the portrait) or `'3d'` (the 3D
+  character). Omit it to let the arcade decide. Anything else is treated as
+  omitted. An arcade older than the tabs ignores it. |
+
 **Returns.** whether the message left the frame — `false` before the bridge is
   up, for an arcade that has no avatar picker here, and past this frame's
   own limit of six a minute.
@@ -5803,6 +5810,54 @@ The portrait's thumbnail, when there is one. Absent means no portrait —
 draw your own placeholder rather than a broken image. Pass it through
 [platformIconUrl](#platformiconurl) before putting it in an `<img src>`.
 
+<a id="friend-avatar3did"></a>
+
+## Friend.avatar3dId
+
+```ts
+readonly avatar3dId?: string
+```
+
+The id of the 3D character the player wears, when they wear one — an
+Arcade item of type `avatar_3d`, chosen on the 3D tab of the Arcade's
+avatar picker. What a game that draws Arcade avatars keys its character
+on: prefer it, load [PlayerIdentity.avatar3dModelUrl](#playeridentity-avatar3dmodelurl), and fall back
+to your own mapping of [PlayerIdentity.avatarIconId](#playeridentity-avatariconid) when it is
+absent.
+
+Independent of the portrait: wearing a 3D character never changes
+`avatarIconId`, and the other way round. Absent means the game's default
+look. On `gem.player` it changes when the player wears another one, and
+`onPlayer` runs again; see `gem.openAvatarPicker`.
+
+<a id="friend-avatar3dmodelurl"></a>
+
+## Friend.avatar3dModelUrl
+
+```ts
+readonly avatar3dModelUrl?: string
+```
+
+The worn 3D character's model — a binary glTF (`.glb`) with one rig,
+`root > body > (head, arm_l, arm_r > hand_socket, leg_l, leg_r)`, and
+possibly animation clips. Load it with three.js's `GLTFLoader`, after
+passing it through [platformIconUrl](#platformiconurl), which pins models to the
+platform's item host exactly as it pins pictures. Absent when no 3D
+character is worn.
+
+<a id="friend-avatar3diconurl"></a>
+
+## Friend.avatar3dIconUrl
+
+```ts
+readonly avatar3dIconUrl?: string
+```
+
+A rendered portrait of the worn 3D character, for a roster or a menu where
+loading the model is too much. Not the 2D portrait
+([PlayerIdentity.avatarIconUrl](#playeridentity-avatariconurl)), which is a separate choice. Pass it
+through [platformIconUrl](#platformiconurl) before putting it in an `<img src>`.
+
 <a id="friend-badges"></a>
 
 ## Friend.badges
@@ -7611,6 +7666,54 @@ The portrait's thumbnail, when there is one. Absent means no portrait —
 draw your own placeholder rather than a broken image. Pass it through
 [platformIconUrl](#platformiconurl) before putting it in an `<img src>`.
 
+<a id="gemplayer-avatar3did"></a>
+
+## GemPlayer.avatar3dId
+
+```ts
+readonly avatar3dId?: string
+```
+
+The id of the 3D character the player wears, when they wear one — an
+Arcade item of type `avatar_3d`, chosen on the 3D tab of the Arcade's
+avatar picker. What a game that draws Arcade avatars keys its character
+on: prefer it, load [PlayerIdentity.avatar3dModelUrl](#playeridentity-avatar3dmodelurl), and fall back
+to your own mapping of [PlayerIdentity.avatarIconId](#playeridentity-avatariconid) when it is
+absent.
+
+Independent of the portrait: wearing a 3D character never changes
+`avatarIconId`, and the other way round. Absent means the game's default
+look. On `gem.player` it changes when the player wears another one, and
+`onPlayer` runs again; see `gem.openAvatarPicker`.
+
+<a id="gemplayer-avatar3dmodelurl"></a>
+
+## GemPlayer.avatar3dModelUrl
+
+```ts
+readonly avatar3dModelUrl?: string
+```
+
+The worn 3D character's model — a binary glTF (`.glb`) with one rig,
+`root > body > (head, arm_l, arm_r > hand_socket, leg_l, leg_r)`, and
+possibly animation clips. Load it with three.js's `GLTFLoader`, after
+passing it through [platformIconUrl](#platformiconurl), which pins models to the
+platform's item host exactly as it pins pictures. Absent when no 3D
+character is worn.
+
+<a id="gemplayer-avatar3diconurl"></a>
+
+## GemPlayer.avatar3dIconUrl
+
+```ts
+readonly avatar3dIconUrl?: string
+```
+
+A rendered portrait of the worn 3D character, for a roster or a menu where
+loading the model is too much. Not the 2D portrait
+([PlayerIdentity.avatarIconUrl](#playeridentity-avatariconurl)), which is a separate choice. Pass it
+through [platformIconUrl](#platformiconurl) before putting it in an `<img src>`.
+
 <a id="gemplayer-badges"></a>
 
 ## GemPlayer.badges
@@ -8669,7 +8772,7 @@ ends, and under an embedder that has no avatar picker.
 ## Gem.openAvatarPicker
 
 ```ts
-openAvatarPicker(): boolean
+openAvatarPicker(options?: { tab?: "2d" | "3d" }): boolean
 ```
 
 Open the arcade's avatar picker over your game, so the player can change
@@ -8684,22 +8787,36 @@ changeAvatar.onclick = () => {
 };
 ```
 
+**Two tabs: 2D and 3D.** The picker has a 2D tab — the portrait, a
+picture ([PlayerIdentity.avatarIconId](#playeridentity-avatariconid)) — and a 3D tab — a whole
+character with its own model ([PlayerIdentity.avatar3dId](#playeridentity-avatar3did),
+[PlayerIdentity.avatar3dModelUrl](#playeridentity-avatar3dmodelurl)). They are separate choices: wearing
+one never changes the other. Pass `{ tab: '3d' }` or `{ tab: '2d' }` to
+open on one; omit it and the arcade decides (a game that draws Arcade
+avatars gets the 3D tab). An arcade older than the tabs ignores it.
+
 **The change arrives as a new player, not as an answer.** Nothing comes
 back from this call. When the player picks a different avatar, the arcade
 pauses your game while the picker is open, then sends the player again —
 your `onPlayer` callback runs and [Gem.player](#gem-player) holds the new
-[PlayerIdentity.avatarIconId](#playeridentity-avatariconid) — and resumes it. Redraw from
-`onPlayer`, which also runs when the player changes their avatar from the
-arcade's own menu without your game asking. A player who closes the picker
-unchanged produces nothing at all.
+[PlayerIdentity.avatar3dId](#playeridentity-avatar3did) or [PlayerIdentity.avatarIconId](#playeridentity-avatariconid) —
+and resumes it. Redraw from `onPlayer`, which also runs when the player
+changes their avatar from the arcade's own menu without your game asking.
+A player who closes the picker unchanged produces nothing at all.
 
 **Your server learns it only when it reads the room again.** A
-server-authoritative game reads each member's `avatar_icon_id` from the
-room read (`GET /v1/games/{game_id}/game-rooms/{game_room_id}`, or
-`gem.room.get()` on a dedicated server); nothing tells the server the
-player changed. So when `onPlayer` brings a different `avatarIconId`, have
-your client tell your server, and have the server re-read the room — never
-trust the id the client sends.
+server-authoritative game reads each member's `avatar_3d_id` and
+`avatar_icon_id` from the room read
+(`GET /v1/games/{game_id}/game-rooms/{game_room_id}`, or `gem.room.get()`
+on a dedicated server); nothing tells the server the player changed. So
+when `onPlayer` brings a different avatar, have your client tell your
+server, and have the server re-read the room — never trust the id the
+client sends.
+
+| Parameter | Type | Description |
+| --- | --- | --- |
+| `options` | `{ tab?: "2d" \| "3d" }` | `tab` — `'2d'` or `'3d'`, the tab to open on. Omit it to let
+  the arcade decide; any other value is treated as omitted. |
 
 **Returns.** `true` when the arcade was asked; `false` when it was not and
   never will be for this call — outside the arcade, before the bridge is
@@ -10339,6 +10456,54 @@ The portrait's thumbnail, when there is one. Absent means no portrait —
 draw your own placeholder rather than a broken image. Pass it through
 [platformIconUrl](#platformiconurl) before putting it in an `<img src>`.
 
+<a id="playeridentity-avatar3did"></a>
+
+## PlayerIdentity.avatar3dId
+
+```ts
+readonly avatar3dId?: string
+```
+
+The id of the 3D character the player wears, when they wear one — an
+Arcade item of type `avatar_3d`, chosen on the 3D tab of the Arcade's
+avatar picker. What a game that draws Arcade avatars keys its character
+on: prefer it, load [PlayerIdentity.avatar3dModelUrl](#playeridentity-avatar3dmodelurl), and fall back
+to your own mapping of [PlayerIdentity.avatarIconId](#playeridentity-avatariconid) when it is
+absent.
+
+Independent of the portrait: wearing a 3D character never changes
+`avatarIconId`, and the other way round. Absent means the game's default
+look. On `gem.player` it changes when the player wears another one, and
+`onPlayer` runs again; see `gem.openAvatarPicker`.
+
+<a id="playeridentity-avatar3dmodelurl"></a>
+
+## PlayerIdentity.avatar3dModelUrl
+
+```ts
+readonly avatar3dModelUrl?: string
+```
+
+The worn 3D character's model — a binary glTF (`.glb`) with one rig,
+`root > body > (head, arm_l, arm_r > hand_socket, leg_l, leg_r)`, and
+possibly animation clips. Load it with three.js's `GLTFLoader`, after
+passing it through [platformIconUrl](#platformiconurl), which pins models to the
+platform's item host exactly as it pins pictures. Absent when no 3D
+character is worn.
+
+<a id="playeridentity-avatar3diconurl"></a>
+
+## PlayerIdentity.avatar3dIconUrl
+
+```ts
+readonly avatar3dIconUrl?: string
+```
+
+A rendered portrait of the worn 3D character, for a roster or a menu where
+loading the model is too much. Not the 2D portrait
+([PlayerIdentity.avatarIconUrl](#playeridentity-avatariconurl)), which is a separate choice. Pass it
+through [platformIconUrl](#platformiconurl) before putting it in an `<img src>`.
+
 <a id="playeridentity-badges"></a>
 
 ## PlayerIdentity.badges
@@ -10377,8 +10542,8 @@ for (const row of opponents) {
 ```
 
 Reads `player_id`, `display_name`, `discriminator`, `display_tag`,
-`avatar_icon_id`, `avatar_icon_url` and `badges`, and nothing else from the
-row. Anything missing, empty or of the wrong type is absent in the result.
+`avatar_icon_id`, `avatar_icon_url`, `avatar_3d_id`, `avatar_3d_model_url`,
+`avatar_3d_icon_url` and `badges`, and nothing else from the row. Anything missing, empty or of the wrong type is absent in the result.
 
 | Parameter | Type |
 | --- | --- |
@@ -10394,9 +10559,10 @@ function platformIconUrl(url: string | undefined): string | undefined
 
 The icon URL, if and only if the platform serves it — otherwise `undefined`.
 
-Use it on every [PlayerIdentity.avatarIconUrl](#playeridentity-avatariconurl) and
-[PlayerBadge.iconUrl](#playerbadge-iconurl) before it reaches an `<img src>`, a texture
-loader or a `fetch`:
+Use it on every [PlayerIdentity.avatarIconUrl](#playeridentity-avatariconurl),
+[PlayerIdentity.avatar3dIconUrl](#playeridentity-avatar3diconurl), [PlayerIdentity.avatar3dModelUrl](#playeridentity-avatar3dmodelurl)
+and [PlayerBadge.iconUrl](#playerbadge-iconurl) before it reaches an `<img src>`, a texture
+loader, a `GLTFLoader` or a `fetch`:
 
 ```js
 import { platformIconUrl } from '@indiegems/gem-web-sdk/sdk';
@@ -12906,6 +13072,54 @@ The portrait's thumbnail, when there is one. Absent means no portrait —
 draw your own placeholder rather than a broken image. Pass it through
 [platformIconUrl](#platformiconurl) before putting it in an `<img src>`.
 
+<a id="leaderboardentry-avatar3did"></a>
+
+## LeaderboardEntry.avatar3dId
+
+```ts
+readonly avatar3dId?: string
+```
+
+The id of the 3D character the player wears, when they wear one — an
+Arcade item of type `avatar_3d`, chosen on the 3D tab of the Arcade's
+avatar picker. What a game that draws Arcade avatars keys its character
+on: prefer it, load [PlayerIdentity.avatar3dModelUrl](#playeridentity-avatar3dmodelurl), and fall back
+to your own mapping of [PlayerIdentity.avatarIconId](#playeridentity-avatariconid) when it is
+absent.
+
+Independent of the portrait: wearing a 3D character never changes
+`avatarIconId`, and the other way round. Absent means the game's default
+look. On `gem.player` it changes when the player wears another one, and
+`onPlayer` runs again; see `gem.openAvatarPicker`.
+
+<a id="leaderboardentry-avatar3dmodelurl"></a>
+
+## LeaderboardEntry.avatar3dModelUrl
+
+```ts
+readonly avatar3dModelUrl?: string
+```
+
+The worn 3D character's model — a binary glTF (`.glb`) with one rig,
+`root > body > (head, arm_l, arm_r > hand_socket, leg_l, leg_r)`, and
+possibly animation clips. Load it with three.js's `GLTFLoader`, after
+passing it through [platformIconUrl](#platformiconurl), which pins models to the
+platform's item host exactly as it pins pictures. Absent when no 3D
+character is worn.
+
+<a id="leaderboardentry-avatar3diconurl"></a>
+
+## LeaderboardEntry.avatar3dIconUrl
+
+```ts
+readonly avatar3dIconUrl?: string
+```
+
+A rendered portrait of the worn 3D character, for a roster or a menu where
+loading the model is too much. Not the 2D portrait
+([PlayerIdentity.avatarIconUrl](#playeridentity-avatariconurl)), which is a separate choice. Pass it
+through [platformIconUrl](#platformiconurl) before putting it in an `<img src>`.
+
 <a id="leaderboardentry-badges"></a>
 
 ## LeaderboardEntry.badges
@@ -14351,6 +14565,54 @@ The portrait's thumbnail, when there is one. Absent means no portrait —
 draw your own placeholder rather than a broken image. Pass it through
 [platformIconUrl](#platformiconurl) before putting it in an `<img src>`.
 
+<a id="playerprofile-avatar3did"></a>
+
+## PlayerProfile.avatar3dId
+
+```ts
+readonly avatar3dId?: string
+```
+
+The id of the 3D character the player wears, when they wear one — an
+Arcade item of type `avatar_3d`, chosen on the 3D tab of the Arcade's
+avatar picker. What a game that draws Arcade avatars keys its character
+on: prefer it, load [PlayerIdentity.avatar3dModelUrl](#playeridentity-avatar3dmodelurl), and fall back
+to your own mapping of [PlayerIdentity.avatarIconId](#playeridentity-avatariconid) when it is
+absent.
+
+Independent of the portrait: wearing a 3D character never changes
+`avatarIconId`, and the other way round. Absent means the game's default
+look. On `gem.player` it changes when the player wears another one, and
+`onPlayer` runs again; see `gem.openAvatarPicker`.
+
+<a id="playerprofile-avatar3dmodelurl"></a>
+
+## PlayerProfile.avatar3dModelUrl
+
+```ts
+readonly avatar3dModelUrl?: string
+```
+
+The worn 3D character's model — a binary glTF (`.glb`) with one rig,
+`root > body > (head, arm_l, arm_r > hand_socket, leg_l, leg_r)`, and
+possibly animation clips. Load it with three.js's `GLTFLoader`, after
+passing it through [platformIconUrl](#platformiconurl), which pins models to the
+platform's item host exactly as it pins pictures. Absent when no 3D
+character is worn.
+
+<a id="playerprofile-avatar3diconurl"></a>
+
+## PlayerProfile.avatar3dIconUrl
+
+```ts
+readonly avatar3dIconUrl?: string
+```
+
+A rendered portrait of the worn 3D character, for a roster or a menu where
+loading the model is too much. Not the 2D portrait
+([PlayerIdentity.avatarIconUrl](#playeridentity-avatariconurl)), which is a separate choice. Pass it
+through [platformIconUrl](#platformiconurl) before putting it in an `<img src>`.
+
 <a id="playerprofile-badges"></a>
 
 ## PlayerProfile.badges
@@ -14697,6 +14959,31 @@ Which template to match, by slug. See
 [CreateRoomOptions.templateSlug](#createroomoptions-templateslug) for where a slug comes from, and why
 `'standard'` resolves even before you have authored any config.
 
+<a id="quickjoinoptions-templateslugs"></a>
+
+## QuickJoinOptions.templateSlugs
+
+```ts
+readonly templateSlugs?: readonly string[]
+```
+
+Several templates this player accepts, by slug — one to eight of them, for
+a game that offers "any of these modes". Pass it INSTEAD of
+[QuickJoinOptions.templateSlug](#quickjoinoptions-templateslug), never beside it.
+
+Open rooms of every listed template are candidates together, and the
+fullest one is joined. **The order matters only when there is none:** the
+room that gets created is made from the first slug listed. Read
+`room.templateSlug` to learn which mode the player landed in.
+
+Every listed template must be one players can quick-join; one that is not
+refuses the whole call rather than being skipped.
+
+```ts
+const room = await gem.rooms.quickJoin({ templateSlugs: ['duel', 'brawl'] });
+startMode(room.templateSlug);
+```
+
 <a id="quickjoinoptions-templateid"></a>
 
 ## QuickJoinOptions.templateId
@@ -15476,6 +15763,13 @@ on a ticket, possibly in another tab or another game — and
 answering. Tell the player; do not loop on it, and do not quietly
 substitute `quickJoin`, which puts them in a different kind of room.
 
+A party leader can meet three more, when the party could not be seated
+together: `version_data_required` — the party did not launch this game
+together; `party_versions_incomplete` — a member's game has not finished
+starting, so wait a moment and queue again; and `party_version_mismatch`
+— a member is on a build that cannot play with the leader's, so everyone
+reloads the game. No ticket was made in any of the three.
+
 <a id="roommanager-list"></a>
 
 ## RoomManager.list
@@ -16669,6 +16963,54 @@ The portrait's thumbnail, when there is one. Absent means no portrait —
 draw your own placeholder rather than a broken image. Pass it through
 [platformIconUrl](#platformiconurl) before putting it in an `<img src>`.
 
+<a id="roommember-avatar3did"></a>
+
+## RoomMember.avatar3dId
+
+```ts
+readonly avatar3dId?: string
+```
+
+The id of the 3D character the player wears, when they wear one — an
+Arcade item of type `avatar_3d`, chosen on the 3D tab of the Arcade's
+avatar picker. What a game that draws Arcade avatars keys its character
+on: prefer it, load [PlayerIdentity.avatar3dModelUrl](#playeridentity-avatar3dmodelurl), and fall back
+to your own mapping of [PlayerIdentity.avatarIconId](#playeridentity-avatariconid) when it is
+absent.
+
+Independent of the portrait: wearing a 3D character never changes
+`avatarIconId`, and the other way round. Absent means the game's default
+look. On `gem.player` it changes when the player wears another one, and
+`onPlayer` runs again; see `gem.openAvatarPicker`.
+
+<a id="roommember-avatar3dmodelurl"></a>
+
+## RoomMember.avatar3dModelUrl
+
+```ts
+readonly avatar3dModelUrl?: string
+```
+
+The worn 3D character's model — a binary glTF (`.glb`) with one rig,
+`root > body > (head, arm_l, arm_r > hand_socket, leg_l, leg_r)`, and
+possibly animation clips. Load it with three.js's `GLTFLoader`, after
+passing it through [platformIconUrl](#platformiconurl), which pins models to the
+platform's item host exactly as it pins pictures. Absent when no 3D
+character is worn.
+
+<a id="roommember-avatar3diconurl"></a>
+
+## RoomMember.avatar3dIconUrl
+
+```ts
+readonly avatar3dIconUrl?: string
+```
+
+A rendered portrait of the worn 3D character, for a roster or a menu where
+loading the model is too much. Not the 2D portrait
+([PlayerIdentity.avatarIconUrl](#playeridentity-avatariconurl)), which is a separate choice. Pass it
+through [platformIconUrl](#platformiconurl) before putting it in an `<img src>`.
+
 <a id="roommember-badges"></a>
 
 ## RoomMember.badges
@@ -17008,6 +17350,20 @@ readonly templateId?: string
 
 Which room template from your game config this room was made from.
 
+<a id="room-templateslug"></a>
+
+## Room.templateSlug
+
+```ts
+readonly templateSlug?: string
+```
+
+The slug of the template this room was made from — the same slug you pass
+as `templateSlug`. After a `quickJoin` naming several templates, this is
+how a game learns which mode the player landed in.
+
+Absent for a room made without a template.
+
 <a id="room-roomtype"></a>
 
 ## Room.roomType
@@ -17437,6 +17793,54 @@ The portrait's thumbnail, when there is one. Absent means no portrait —
 draw your own placeholder rather than a broken image. Pass it through
 [platformIconUrl](#platformiconurl) before putting it in an `<img src>`.
 
+<a id="showcasefriendentry-avatar3did"></a>
+
+## ShowcaseFriendEntry.avatar3dId
+
+```ts
+readonly avatar3dId?: string
+```
+
+The id of the 3D character the player wears, when they wear one — an
+Arcade item of type `avatar_3d`, chosen on the 3D tab of the Arcade's
+avatar picker. What a game that draws Arcade avatars keys its character
+on: prefer it, load [PlayerIdentity.avatar3dModelUrl](#playeridentity-avatar3dmodelurl), and fall back
+to your own mapping of [PlayerIdentity.avatarIconId](#playeridentity-avatariconid) when it is
+absent.
+
+Independent of the portrait: wearing a 3D character never changes
+`avatarIconId`, and the other way round. Absent means the game's default
+look. On `gem.player` it changes when the player wears another one, and
+`onPlayer` runs again; see `gem.openAvatarPicker`.
+
+<a id="showcasefriendentry-avatar3dmodelurl"></a>
+
+## ShowcaseFriendEntry.avatar3dModelUrl
+
+```ts
+readonly avatar3dModelUrl?: string
+```
+
+The worn 3D character's model — a binary glTF (`.glb`) with one rig,
+`root > body > (head, arm_l, arm_r > hand_socket, leg_l, leg_r)`, and
+possibly animation clips. Load it with three.js's `GLTFLoader`, after
+passing it through [platformIconUrl](#platformiconurl), which pins models to the
+platform's item host exactly as it pins pictures. Absent when no 3D
+character is worn.
+
+<a id="showcasefriendentry-avatar3diconurl"></a>
+
+## ShowcaseFriendEntry.avatar3dIconUrl
+
+```ts
+readonly avatar3dIconUrl?: string
+```
+
+A rendered portrait of the worn 3D character, for a roster or a menu where
+loading the model is too much. Not the 2D portrait
+([PlayerIdentity.avatarIconUrl](#playeridentity-avatariconurl)), which is a separate choice. Pass it
+through [platformIconUrl](#platformiconurl) before putting it in an `<img src>`.
+
 <a id="showcasefriendentry-badges"></a>
 
 ## ShowcaseFriendEntry.badges

package/docs/api/api-reference-server.md

@@ -1,6 +1,6 @@
 # The server surface — API reference
 
-Generated from `@indiegems/gem-web-sdk/sdk` v10.4.0, the version of the package this file ships in. Every symbol below carries an explicit anchor, its `anchor` in `reference.json` beside this file.
+Generated from `@indiegems/gem-web-sdk/sdk` v11.1.0, the version of the package this file ships in. Every symbol below carries an explicit anchor, its `anchor` in `reference.json` beside this file.
 
 `@indiegems/gem-web-sdk/sdk` is the one import a game writes, wherever its code runs. `@indiegems/gem-web-sdk/server` exports exactly the symbols on this page and nothing else, for a build that wants only this half.