@gameable/presentation

Interfaces

FreezeMessage

Existing targeted client movement freeze.

Properties

frozen

frozen: boolean;

---

LoadedRequest

Existing loaded acknowledgement; authority validates this round token.

Properties

round

round: number;

---

LoadingModel

Loading stages retain their source, outcome and optional byte progress.

Example

import type { LoadingModel } from 'gameable/presentation';
const state: LoadingModel = { source: 'engine', stage: 'Starting', ready: false, failed: false };
console.log(state.source);

Properties

failed

failed: boolean;

loaded?

optional loaded?: number;

ready

ready: boolean;

source

source: "character" | "bundle" | "round" | "engine";

stage

stage: string;

total?

optional total?: number;

---

MatchCue

Bounded private-seat cue history; sequence is monotonic across seat replacement.

Properties

sequence

sequence: number;

sound

sound: 
  | "click"
  | "tick"
  | "go"
  | "checkpoint"
  | "fall"
  | "jump"
  | "land"
  | "bump"
  | "respawn"
  | "finish"
  | "readyOn"
  | "readyOff";

---

MatchModel

Authority HUD payload. Revision must change when reused arrays mutate.

Properties

grounded

grounded: boolean;

me

me: number;

phase

phase: MatchPhase;

revision

revision: number;

roster

roster: readonly MatchSeat[];

round

round: number;

seconds

seconds: number;

sfx

sfx: object;

events

events: readonly MatchCue[];

sequence

sequence: number;

---

MatchSeat

One occupied or spectator seat in an authority-produced roster.

Properties

entity

entity: number;

loaded

loaded: boolean;

name

name: string;

place

place: number;

ready

ready: boolean;

seat

seat: number;

spectator

spectator: boolean;

---

PlayerSettings

Validated portable settings; absent schemaVersion is the legacy host-only format.

Properties

features

features: FeatureSpec;

gameplay?

optional gameplay?: object;

characters

characters: string[];

checkpoints

checkpoints: object;

checkpoints.axis

axis: "z";

checkpoints.direction

direction: "decreasing";

checkpoints.fallY

fallY: number = finite;

checkpoints.lobbyRespawn

lobbyRespawn: "seat-start";

checkpoints.maxAbsX

maxAbsX: number = nonnegative;

checkpoints.minY

minY: number = finite;

checkpoints.points

points: number[][];

checkpoints.resetKnock

resetKnock: boolean = boolean;

checkpoints.thresholds

thresholds: number[];

contact

contact: object;

contact.carryTolerance

carryTolerance: number = nonnegative;

contact.foot

foot: number = nonnegative;

floors

floors: number[][];

knock

knock: object;

knock.cooldown

cooldown: number = seconds;

knock.duration

duration: number = seconds;

knock.margin

margin: number = nonnegative;

knock.speed

speed: number = nonnegative;

match

match: object;

match.afterFirstSeconds

afterFirstSeconds: number = seconds;

match.cardSeconds

cardSeconds: number = seconds;

match.countdownSeconds

countdownSeconds: number = seconds;

match.lateJoin

lateJoin: "spectate-after-loading";

match.limitSeconds

limitSeconds: number = seconds;

match.loadingSeconds

loadingSeconds: number = seconds;

match.minPlayers

minPlayers: number = seats;

match.resultsSeconds

resultsSeconds: number = seconds;

match.soloMinPlayers

soloMinPlayers: number = seats;

match.spectatorSpawnZ

spectatorSpawnZ: number = finite;

match.start

start: "all-ready";

movers

movers: object[];

placing

placing: object;

placing.at

at: number = finite;

placing.axis

axis: "z";

placing.direction

direction: "decreasing";

placing.freezeFinishers

freezeFinishers: boolean = boolean;

placing.maxAbsX

maxAbsX: number = nonnegative;

placing.maxY

maxY: number = finite;

placing.minY

minY: number = finite;

placing.requiresAllCheckpoints

requiresAllCheckpoints: false;

placing.tieBreak

tieBreak: "seat";

spawns

spawns: number[][];

walk

walk: object;

walk.body

body: object;

walk.body.dims

dims: number[];

walk.body.flags

flags: object;

walk.body.flags.asleep

asleep: boolean | undefined;

walk.body.flags.ccd

ccd: boolean | undefined;

walk.body.flags.lockRotation

lockRotation: boolean | undefined;

walk.body.flags.noSleep

noSleep: boolean | undefined;

walk.body.flags.reportContacts

reportContacts: boolean | undefined;

walk.body.flags.reportStay

reportStay: boolean | undefined;

walk.body.flags.sensor

sensor: boolean | undefined;

walk.body.kind

kind: "character";

walk.body.layer

layer: object = layers;

Index Signature

[key: string]: boolean | undefined

walk.body.mask

mask: object = layers;

Index Signature

[key: string]: boolean | undefined

walk.body.mass

mass: number = positive;

walk.body.shape

shape: "capsule";

walk.cameraMaxPitch

cameraMaxPitch: number = finite;

walk.cameraMinPitch

cameraMinPitch: number = finite;

walk.cameraPitch

cameraPitch: number = finite;

walk.jumpSpeed

jumpSpeed: number = nonnegative;

walk.prediction

prediction: "own-body";

walk.runSpeed

runSpeed: number = nonnegative;

walk.scheme

scheme: "third-person";

walk.walkSpeed

walkSpeed: number = nonnegative;

input?

optional input?: object;

touch

touch: "gestures" | "sticks";

maxPlayers

maxPlayers: number;

name?

optional name?: string;

physics

physics: Omit<PhysicsOptions, "wasmUrl">;

player?

optional player?: Omit<PlayerSpec, "character" | "spawn" | "prefab">;

scene?

optional scene?: object;

arches

arches: object;

arches.finish

finish: object = arch;

arches.finish.pillarX

pillarX: number = positive;

arches.finish.top

top: number = positive;

arches.finish.z

z: number = finite;

arches.start

start: object = arch;

arches.start.pillarX

pillarX: number = positive;

arches.start.top

top: number = positive;

arches.start.z

z: number = finite;

arrows

arrows: object;

arrows.halfLength

halfLength: number = positive;

arrows.halfWidth

halfWidth: number = positive;

arrows.margin

margin: number = nonnegative;

gapEdges

gapEdges: number[];

palette

palette: number[][];

renderer

renderer: "raceCandy";

sea

sea: object;

sea.size

size: number = positive;

sea.y

y: number = finite;

version

version: 1 | undefined;

schemaVersion?

optional schemaVersion?: 1;

sendHz

sendHz: number;

ui?

optional ui?: object;

actions

actions: ("leave" | "ready" | "change-character")[] | undefined;

characters

characters: 
  | {
  allowDefault: boolean;
  allowPaste: boolean;
  changePolicy: "lobby-unready-swap";
  endpoint: string;
  storageKey: string;
  studio: string;
}
  | undefined;

connection

connection: 
  | {
  refusalReasons: ("full" | "capacity" | "busy")[];
  rejoinReasons: ("idle" | "version")[];
  retrySeconds: number;
}
  | undefined;

controls

controls: 
  | {
  cancel: string;
  failed: "stand-in";
  localLoadTimeoutSeconds: number;
  ready: string;
  readyKey: "KeyR";
  roundProgress: boolean;
}
  | undefined;

cues

cues: 
  | {
  effects: {
     fallFlashMs: number;
     finish: "confetti";
  };
  history: 8;
  localJump: "space-grounded";
  source: string;
  synth: "race-v1";
}
  | undefined;

errors

errors: 
  | {
  causes: number;
  warnings: boolean;
}
  | undefined;

hint

hint: 
  | {
  text: string;
}
  | undefined;

hud

hud: 
  | {
  capacity: number;
  countdown: {
     cardSeconds: number;
     from: number;
     goSeconds: number;
     instruction: string;
  };
  labels: {
     lobby: string;
  };
  results: {
     missingPlace: string;
     returnLabel: string;
     sort: "place";
     spectator: string;
  };
  source: string;
  type: "match";
  version: 1 | undefined;
}
  | undefined;

loading

loading: 
  | {
  characterStatus: boolean;
  renderer: "status";
  roundBarrier: boolean;
  version: 1 | undefined;
}
  | undefined;

menu

menu: 
  | {
  code: {
     max: number;
     min: number;
     uppercase: true;
  };
  labels: {
     new: string;
     quick: string;
     solo: string;
  };
  modes: ("solo" | "join" | "new" | "quick")[];
  title: string;
}
  | undefined;

modules

modules: object[] | undefined;

players

players: 
  | {
  arrivalMs: number;
  contactDiscs: boolean;
  names: boolean;
  standInPalette: "race";
}
  | undefined;

rooms

rooms: 
  | {
  activeLabel: string;
  activePhases: ("lobby" | "loading" | "countdown" | "racing" | "results")[];
  idleLabel: string;
  public: boolean;
}
  | undefined;

session

session: 
  | {
  rejoin: boolean;
  returnTo: "menu";
}
  | undefined;

theme

theme: 
  | {
  gameplay: "gameable" | "raceCandy";
  shell: "gameable";
}
  | undefined;

world

world: WorldSpec;

---

StartIntent

Session intent selected before engine boot.

Example

import type { StartIntent } from 'gameable/presentation';
const intent: StartIntent = { kind: 'solo' };
console.log(intent.kind);

Properties

code?

optional code?: string;

kind

kind: "solo" | "join" | "new" | "quick";

look?

optional look?: string;

Type Aliases

GameplaySettings

type GameplaySettings = ReturnType<typeof gameplaySchema>;

Authored race module data embedded in the guest's rules.gameplay.

---

MatchPhase

type MatchPhase = "lobby" | "loading" | "countdown" | "racing" | "results";

Semantic match phases carried in the HUD namespace.

---

PresentationModule

type PresentationModule = ReturnType<typeof moduleSchema>;

Versioned engine-owned module selection; no code URLs cross this contract.

---

ReadyRequest

type ReadyRequest = null;

Existing ready request: null payload, eight-byte transport limit.

---

SceneSettings

type SceneSettings = ReturnType<typeof sceneSchema>;

Named engine-owned scene preset options.

---

UISettings

type UISettings = ReturnType<typeof uiSchema>;

Closed, engine-owned presentation selections.

Functions

assertDefinitionSettings()

function assertDefinitionSettings(settings, definition): void;

Reject authored host/guest drift, including module data embedded as rules.gameplay.

Parameters

Parameter	Type	Description
settings	PlayerSettings	Validated authored settings.
definition	GameDefinition	The guest game declaration loaded by the CLI.

Returns

void

Example

const settings = parseSettings({ features: {}, world: {}, physics: {}, maxPlayers: 1, sendHz: 20 });
assertDefinitionSettings(settings, {});

---

canChangeCharacter()

function canChangeCharacter(
   phase, 
   ready, 
   spectator?
): boolean;

Character swaps preserve the room and are available only while unready in lobby.

Parameters

Parameter	Type	Default value	Description
phase	string | undefined	undefined	Authoritative match phase.
ready	boolean | undefined	undefined	Local seat readiness.
spectator	boolean	false	Whether the local seat is spectating.

Returns

boolean

Whether an in-place lobby swap is allowed.

---

characterName()

function characterName(result, look?): string;

Resolve the display name without exposing a source URL.

Parameters

Parameter	Type	Description
result	MyCharactersResult | null	Catalog result, or null before it arrives.
look?	string	Canonical character source, or undefined for the default character.

Returns

string

The selected name or a stable fallback.

---

characterPanel()

function characterPanel(result): "signed-out" | "unavailable" | "loading" | "cards" | "empty";

Project catalog state without DOM or transport.

Parameters

Parameter	Type	Description
result	MyCharactersResult | null	Catalog result, or null before it arrives.

Returns

"signed-out" | "unavailable" | "loading" | "cards" | "empty"

The catalog panel state.

---

characterSelection()

function characterSelection(look?): CharacterSelection;

Default is an explicit choice, separate from no selection.

Parameters

Parameter	Type	Description
look?	string	Canonical character source, or undefined for the default character.

Returns

CharacterSelection

An explicit selection state, distinct from choosing the default.

---

connectionModel()

function connectionModel(
   state, 
   reason, 
   until, 
   now, 
   settings
): object;

Pure connection projection; the caller records the first refusal deadline.

Parameters

Parameter	Type	Description
state	string	Current connection state.
reason	string	Transport closure reason.
until	number	First refusal deadline in milliseconds.
now	number	Current time in milliseconds.
settings	{ refusalReasons: ("full" | "capacity" | "busy")[]; rejoinReasons: ("idle" | "version")[]; retrySeconds: number; }	Validated presentation settings.
settings.refusalReasons	("full" | "capacity" | "busy")[]	-
settings.rejoinReasons	("idle" | "version")[]	-
settings.retrySeconds	number	-

Returns

object

Connection text, visibility, cooldown and permitted actions.

message

message: string;

refused

refused: boolean;

rejoin

rejoin: boolean;

retry

retry: boolean;

seconds

seconds: number;

visible

visible: boolean = closed;

---

controlsModel()

function controlsModel(
   model, 
   character, 
   settings
): object;

Resolve readiness controls without DOM or transport access.

Parameters

Parameter	Type	Description
model	MatchModel | null	Authority snapshot, if received.
character	CharacterLoad	Local visual readiness.
settings	{ cancel: string; failed: "stand-in"; localLoadTimeoutSeconds: number; ready: string; readyKey: "KeyR"; roundProgress: boolean; }	Authored control labels.
settings.cancel	string	-
settings.failed	"stand-in"	-
settings.localLoadTimeoutSeconds	number	-
settings.ready	string	-
settings.readyKey	"KeyR"	-
settings.roundProgress	boolean	-

Returns

object

Button visibility, text and status.

label

label: string;

progress

progress: number | null;

shown

shown: boolean;

status

status: string;

---

createConnectionScreen()

function createConnectionScreen(options): object;

Render network closure with a single refusal deadline and removable timer/listener.

Parameters

Parameter	Type	Description
options	{ allowRejoin: boolean; mount: HTMLElement; net: { closeReason: string; state: string; onChange: () => void; }; settings: { refusalReasons: ("full" | "capacity" | "busy")[]; rejoinReasons: ("idle" | "version")[]; retrySeconds: number; }; closeLobby: void; menu: void; rejoin: void; }	Validated configuration and caller-owned host callbacks.
options.allowRejoin	boolean	Whether the session allows rejoining.
options.mount	HTMLElement	Caller-owned screen container.
options.net	{ closeReason: string; state: string; onChange: () => void; }	Observable connection state.
options.net.closeReason	string	Final closure or refusal reason.
options.net.state	string	Current transport state.
options.net.onChange	Subscribe to transport state changes.
options.settings	{ refusalReasons: ("full" | "capacity" | "busy")[]; rejoinReasons: ("idle" | "version")[]; retrySeconds: number; }	Validated presentation settings.
options.settings.refusalReasons	("full" | "capacity" | "busy")[]	-
options.settings.rejoinReasons	("idle" | "version")[]	-
options.settings.retrySeconds	number	-
options.closeLobby	Hide lobby actions when the connection closes.
options.menu	Return to the menu after cleanup.
options.rejoin	Restart with the same session intent after cleanup.

Returns

object

The mounted screen and its timer/subscription cleanup.

element

element: HTMLElement;

dispose()

dispose(): void;

Returns

void

---

createControls()

function createControls(
   doc, 
   settings, 
   toggle, 
   loadingSeconds
): object;

Build persistent controls; updates never detach a pressed button.

Parameters

Parameter	Type	Description
doc	Document	Drawing document.
settings	{ cancel: string; failed: "stand-in"; localLoadTimeoutSeconds: number; ready: string; readyKey: "KeyR"; roundProgress: boolean; }	Authored labels and key binding.
settings.cancel	string	-
settings.failed	"stand-in"	-
settings.localLoadTimeoutSeconds	number	-
settings.ready	string	-
settings.readyKey	"KeyR"	-
settings.roundProgress	boolean	-
toggle	() => void	Send the readiness action.
loadingSeconds	number	Round barrier duration.

Returns

object

Replaceable controls drawing and disposal.

button

button: HTMLButtonElement;

element

element: HTMLDivElement;

dispose()

dispose(): void;

Returns

void

render()

render(model, character): void;

Parameters

Parameter	Type
model	MatchModel | null
character	CharacterLoad

Returns

void

---

createCues()

function createCues(sink?): object;

Own a replaceable sound/effect sink for exactly one session.

Parameters

Parameter	Type	Description
sink?	{ dispose: void | Promise<void>; emit: void; }	Sound or drawing implementation; omitted for silent presentation.
sink.dispose?	Release drawing or audio resources.
sink.emit?	Deliver a sound or effect once.

Returns

object

Cue delivery and idempotent teardown.

dispose()

dispose(): void | Promise<void>;

Returns

void | Promise<void>

set()

set(model): void;

Parameters

Parameter	Type
model	MatchModel

Returns

void

---

createCuesModel()

function createCuesModel(emit): (model) => void;

Consume sequence history independently of snapshots, rounds and DOM replacement.

Parameters

Parameter	Type	Description
emit	(cue) => void	Replaceable cue sink.

Returns

A consumer retaining its cursor until the session ends.

(model) => void

---

createErrorScreen()

function createErrorScreen(options): object;

Separate fatal and warning channels; drawing can be replaced without changing the projection.

Parameters

Parameter	Type	Description
options	{ menu?: () => void; mount: HTMLElement; settings: { causes: number; warnings: boolean; }; }	Validated configuration and caller-owned host callbacks.
options.menu?	() => void	Return to the menu after cleanup.
options.mount	HTMLElement	Caller-owned screen container.
options.settings	{ causes: number; warnings: boolean; }	Validated presentation settings.
options.settings.causes	number	-
options.settings.warnings	boolean	-

Returns

object

Independent fatal and warning drawing channels and their cleanup.

element

element: HTMLElement;

dispose()

dispose(): void;

Returns

void

show()

show(error, severity): void;

Parameters

Parameter	Type
error	unknown
severity	"fatal" | "warning"

Returns

void

---

createLoadingScreen()

function createLoadingScreen(mount): object;

Replaceable status drawing for any loading source.

Parameters

Parameter	Type	Description
mount	HTMLElement	Caller-owned screen container.

Returns

object

A replaceable loading renderer and its cleanup.

element

element: HTMLParagraphElement;

dispose()

dispose(): void;

Returns

void

render()

render(model): void;

Parameters

Parameter	Type
model	LoadingModel

Returns

void

---

createMatchHud()

function createMatchHud(options): object;

Draw a match namespace through the host's replaceable HUD seam.

Parameters

Parameter	Type	Description
options	{ character: (model) => CharacterLoad; controls?: { cancel: string; failed: "stand-in"; localLoadTimeoutSeconds: number; ready: string; readyKey: "KeyR"; roundProgress: boolean; }; cues?: { dispose: void | Promise<void>; emit: void; }; cueSettings?: { effects: { fallFlashMs: number; finish: "confetti"; }; history: 8; localJump: "space-grounded"; source: string; synth: "race-v1"; }; hint?: string; hud: { capacity: number; countdown: { cardSeconds: number; from: number; goSeconds: number; instruction: string; }; labels: { lobby: string; }; results: { missingPlace: string; returnLabel: string; sort: "place"; spectator: string; }; source: string; type: "match"; version: 1 | undefined; }; loadingSeconds: number; mount: HTMLElement; ready: () => void; theme?: "gameable" | "raceCandy"; }	Authored configuration, mount and page-owned actions.
options.character	(model) => CharacterLoad	Read character visual readiness.
options.controls?	{ cancel: string; failed: "stand-in"; localLoadTimeoutSeconds: number; ready: string; readyKey: "KeyR"; roundProgress: boolean; }	Optional readiness controls.
options.controls.cancel	string	-
options.controls.failed	"stand-in"	-
options.controls.localLoadTimeoutSeconds	number	-
options.controls.ready	string	-
options.controls.readyKey	"KeyR"	-
options.controls.roundProgress	boolean	-
options.cues?	{ dispose: void | Promise<void>; emit: void; }	Replaceable sound and effect implementation.
options.cues.dispose	Release sound and effect resources.
options.cues.emit	Deliver an unseen authority cue.
options.cueSettings?	{ effects: { fallFlashMs: number; finish: "confetti"; }; history: 8; localJump: "space-grounded"; source: string; synth: "race-v1"; }	Optional engine-owned race-v1 synth and effects.
options.cueSettings.effects	{ fallFlashMs: number; finish: "confetti"; }	-
options.cueSettings.effects.fallFlashMs	number	-
options.cueSettings.effects.finish	"confetti"	-
options.cueSettings.history	8	-
options.cueSettings.localJump	"space-grounded"	-
options.cueSettings.source	string	-
options.cueSettings.synth	"race-v1"	-
options.hint?	string	Optional movement instructions.
options.hud	{ capacity: number; countdown: { cardSeconds: number; from: number; goSeconds: number; instruction: string; }; labels: { lobby: string; }; results: { missingPlace: string; returnLabel: string; sort: "place"; spectator: string; }; source: string; type: "match"; version: 1 | undefined; }	Validated match namespace and text settings.
options.hud.capacity	number	-
options.hud.countdown	{ cardSeconds: number; from: number; goSeconds: number; instruction: string; }	-
options.hud.countdown.cardSeconds	number	-
options.hud.countdown.from	number	-
options.hud.countdown.goSeconds	number	-
options.hud.countdown.instruction	string	-
options.hud.labels	{ lobby: string; }	-
options.hud.labels.lobby	string	-
options.hud.results	{ missingPlace: string; returnLabel: string; sort: "place"; spectator: string; }	-
options.hud.results.missingPlace	string	-
options.hud.results.returnLabel	string	-
options.hud.results.sort	"place"	-
options.hud.results.spectator	string	-
options.hud.source	string	-
options.hud.type	"match"	-
options.hud.version	1 | undefined	-
options.loadingSeconds	number	Authority loading deadline in seconds.
options.mount	HTMLElement	Caller-owned overlay container.
options.ready	() => void	Request a readiness toggle.
options.theme?	"gameable" | "raceCandy"	Named engine-owned gameplay theme.

Returns

HUD renderer plus a frame refresh for asynchronous character loading.

element

element: HTMLElement;

refresh

refresh: () => void;

Refresh controls after asynchronous loading, including unchanged HUD frames.

Returns

void

current

Get Signature

get current(): MatchModel | null;

Returns

MatchModel | null

model

Get Signature

get model(): 
  | {
[key: string]: string | MatchModel;
  message: string;
}
  | null;

Returns

| { [key: string]: string | MatchModel; message: string; } | null

clear()

clear(): void;

Returns

void

dispose()

dispose(): void | Promise<void>;

Returns

void | Promise<void>

set()

set(json): boolean;

Parameters

Parameter	Type
json	string | undefined

Returns

boolean

---

createMatchModel()

function createMatchModel(source): object;

Replace snapshots even when the authority reuses its roster and cue arrays.

Parameters

Parameter	Type	Description
source	string	Configured HUD namespace.

Returns

object

A DOM-free model sink. Undefined frames preserve the snapshot; clear removes it.

current

Get Signature

get current(): MatchModel | null;

Returns

MatchModel | null

clear()

clear(): void;

Returns

void

set()

set(json): boolean;

Parameters

Parameter	Type
json	string | undefined

Returns

boolean

---

createRoomsScreen()

function createRoomsScreen(options): object;

Subscribe to a replaceable transport and close late results after unmount.

Parameters

Parameter	Type	Description
options	{ mount: HTMLElement; settings: { activeLabel: string; activePhases: ("lobby" | "loading" | "countdown" | "racing" | "results")[]; idleLabel: string; public: boolean; }; version: string; join: void; load: Promise<LiveRoomList>; }	Validated configuration and caller-owned host callbacks.
options.mount	HTMLElement	Caller-owned screen container.
options.settings	{ activeLabel: string; activePhases: ("lobby" | "loading" | "countdown" | "racing" | "results")[]; idleLabel: string; public: boolean; }	Validated presentation settings.
options.settings.activeLabel	string	-
options.settings.activePhases	("lobby" | "loading" | "countdown" | "racing" | "results")[]	-
options.settings.idleLabel	string	-
options.settings.public	boolean	-
options.version	string	Immutable game version to browse.
options.join	Join the selected room code.
options.load	Open a replaceable catalog or room-list transport.

Returns

object

A live room-list screen and its transport cleanup.

element

element: HTMLElement;

dispose()

dispose(): void;

Returns

void

---

createSession()

function createSession(): object;

Reverse-order asynchronous cleanup, also used for failed boots.

Returns

object

A lifetime whose disposal runs once and awaits every registered cleanup.

dispose()

dispose(): Promise<void>;

Returns

Promise<void>

use()

use(cleanup): void;

Parameters

Parameter	Type
cleanup	() => void | Promise<void>

Returns

void

---

createSessionLifetime()

function createSessionLifetime(options): object;

Track loading and round acknowledgements without depending on HUD emission cadence. Missing entries wait locally but do not block the round, matching the reference policy.

Parameters

Parameter	Type	Description
options	{ character: (entity) => CharacterLoad | "missing"; now?: () => number; send: (name, payload) => boolean; timeoutSeconds: number; }	Replaceable clock, load lookup and transport bindings.
options.character	(entity) => CharacterLoad | "missing"	Read visual readiness; missing entries are allowed at the round barrier.
options.now?	() => number	Clock in milliseconds.
options.send	(name, payload) => boolean	Send an existing match protocol message; false retries.
options.timeoutSeconds	number	Maximum visual loading time before using a stand-in.

Returns

object

A per-session frame reader and action binding.

character()

character(model): CharacterLoad;

Parameters

Parameter	Type
model	MatchModel | null

Returns

CharacterLoad

dispose()

dispose(): void;

Returns

void

frame()

frame(model): void;

Parameters

Parameter	Type
model	MatchModel | null

Returns

void

ready()

ready(): void;

Returns

void

reset()

reset(entity): void;

Parameters

Parameter	Type
entity	number

Returns

void

---

createStartMenu()

function createStartMenu(options): object;

Draw mode choices; the caller owns character selection and room transport.

Parameters

Parameter	Type	Description
options	{ change?: () => void; mount: HTMLElement; name: string; settings: { code: { max: number; min: number; uppercase: true; }; labels: { new: string; quick: string; solo: string; }; modes: ("solo" | "join" | "new" | "quick")[]; title: string; }; choose: void; }	Validated configuration and caller-owned host callbacks.
options.change?	() => void	Open the character picker.
options.mount	HTMLElement	Caller-owned screen container.
options.name	string	Selected character display name.
options.settings	{ code: { max: number; min: number; uppercase: true; }; labels: { new: string; quick: string; solo: string; }; modes: ("solo" | "join" | "new" | "quick")[]; title: string; }	Validated presentation settings.
options.settings.code	{ max: number; min: number; uppercase: true; }	-
options.settings.code.max	number	-
options.settings.code.min	number	-
options.settings.code.uppercase	true	-
options.settings.labels	{ new: string; quick: string; solo: string; }	-
options.settings.labels.new	string	-
options.settings.labels.quick	string	-
options.settings.labels.solo	string	-
options.settings.modes	("solo" | "join" | "new" | "quick")[]	-
options.settings.title	string	-
options.choose	Deliver the selected session intent, or end the loop with undefined.

Returns

object

Mode and room-code controls with explicit disposal.

element

element: HTMLElement;

dispose()

dispose(): void;

Returns

void

---

definitionSettings()

function definitionSettings(definition, physics): PlayerSettings;

Derive the legacy host fields without executable prefab/spawn data.

Parameters

Parameter	Type	Description
definition	GameDefinition	The guest game declaration loaded by the CLI.
physics	Omit<PhysicsOptions, "wasmUrl">	Validated host physics options.

Returns

PlayerSettings

Declarative settings derived from the definition.

Example

console.log(definitionSettings({}, {}).maxPlayers); // 1

---

directStart()

function directStart(code?): StartIntent | undefined;

Direct links skip mode selection, after character selection.

Parameters

Parameter	Type	Description
code?	string	Direct room-link value.

Returns

StartIntent | undefined

The direct session intent, or undefined to open the menu.

---

errorModel()

function errorModel(error, causes): string;

Bound fatal cause chains, including cyclic causes.

Parameters

Parameter	Type	Description
error	unknown	Host failure or warning.
causes	number	Maximum nested causes to include.

Returns

string

A bounded readable cause chain.

---

errorView()

function errorView(
   error, 
   severity, 
   settings
): object;

Project fatal errors and optional warnings independently of their renderer.

Parameters

Parameter	Type	Description
error	unknown	Host failure or warning.
severity	"fatal" | "warning"	Fatal failure or recoverable warning channel.
settings	{ causes: number; warnings: boolean; }	Validated presentation settings.
settings.causes	number	-
settings.warnings	boolean	-

Returns

object

Severity, visibility and readable error text.

message

message: string;

severity

severity: "fatal" | "warning";

visible

visible: boolean;

---

installCourseScene()

function installCourseScene(
   engine, 
   gameplay, 
   scene, 
   localEntity?
): () => void;

Install the page's candy course once after boot.

Parameters

Parameter	Type	Description
engine	Engine	Booted host and rendering services.
gameplay	{ characters: string[]; checkpoints: { axis: "z"; direction: "decreasing"; fallY: number; lobbyRespawn: "seat-start"; maxAbsX: number; minY: number; points: number[][]; resetKnock: boolean; thresholds: number[]; }; contact: { carryTolerance: number; foot: number; }; floors: number[][]; knock: { cooldown: number; duration: number; margin: number; speed: number; }; match: { afterFirstSeconds: number; cardSeconds: number; countdownSeconds: number; lateJoin: "spectate-after-loading"; limitSeconds: number; loadingSeconds: number; minPlayers: number; resultsSeconds: number; soloMinPlayers: number; spectatorSpawnZ: number; start: "all-ready"; }; movers: object[]; placing: { at: number; axis: "z"; direction: "decreasing"; freezeFinishers: boolean; maxAbsX: number; maxY: number; minY: number; requiresAllCheckpoints: false; tieBreak: "seat"; }; spawns: number[][]; walk: { body: { dims: number[]; flags: { asleep: boolean | undefined; ccd: boolean | undefined; lockRotation: boolean | undefined; noSleep: boolean | undefined; reportContacts: boolean | undefined; reportStay: boolean | undefined; sensor: boolean | undefined; }; kind: "character"; layer: { [key: string]: boolean | undefined; }; mask: { [key: string]: boolean | undefined; }; mass: number; shape: "capsule"; }; cameraMaxPitch: number; cameraMinPitch: number; cameraPitch: number; jumpSpeed: number; prediction: "own-body"; runSpeed: number; scheme: "third-person"; walkSpeed: number; }; }	Validated course collision and mover data.
gameplay.characters	string[]	-
gameplay.checkpoints	{ axis: "z"; direction: "decreasing"; fallY: number; lobbyRespawn: "seat-start"; maxAbsX: number; minY: number; points: number[][]; resetKnock: boolean; thresholds: number[]; }	-
gameplay.checkpoints.axis?	"z"	-
gameplay.checkpoints.direction?	"decreasing"	-
gameplay.checkpoints.fallY?	number	-
gameplay.checkpoints.lobbyRespawn?	"seat-start"	-
gameplay.checkpoints.maxAbsX?	number	-
gameplay.checkpoints.minY?	number	-
gameplay.checkpoints.points?	number[][]	-
gameplay.checkpoints.resetKnock?	boolean	-
gameplay.checkpoints.thresholds?	number[]	-
gameplay.contact?	{ carryTolerance: number; foot: number; }	-
gameplay.contact.carryTolerance?	number	-
gameplay.contact.foot?	number	-
gameplay.floors?	number[][]	-
gameplay.knock?	{ cooldown: number; duration: number; margin: number; speed: number; }	-
gameplay.knock.cooldown?	number	-
gameplay.knock.duration?	number	-
gameplay.knock.margin?	number	-
gameplay.knock.speed?	number	-
gameplay.match?	{ afterFirstSeconds: number; cardSeconds: number; countdownSeconds: number; lateJoin: "spectate-after-loading"; limitSeconds: number; loadingSeconds: number; minPlayers: number; resultsSeconds: number; soloMinPlayers: number; spectatorSpawnZ: number; start: "all-ready"; }	-
gameplay.match.afterFirstSeconds?	number	-
gameplay.match.cardSeconds?	number	-
gameplay.match.countdownSeconds?	number	-
gameplay.match.lateJoin?	"spectate-after-loading"	-
gameplay.match.limitSeconds?	number	-
gameplay.match.loadingSeconds?	number	-
gameplay.match.minPlayers?	number	-
gameplay.match.resultsSeconds?	number	-
gameplay.match.soloMinPlayers?	number	-
gameplay.match.spectatorSpawnZ?	number	-
gameplay.match.start?	"all-ready"	-
gameplay.movers?	object[]	-
gameplay.placing?	{ at: number; axis: "z"; direction: "decreasing"; freezeFinishers: boolean; maxAbsX: number; maxY: number; minY: number; requiresAllCheckpoints: false; tieBreak: "seat"; }	-
gameplay.placing.at?	number	-
gameplay.placing.axis?	"z"	-
gameplay.placing.direction?	"decreasing"	-
gameplay.placing.freezeFinishers?	boolean	-
gameplay.placing.maxAbsX?	number	-
gameplay.placing.maxY?	number	-
gameplay.placing.minY?	number	-
gameplay.placing.requiresAllCheckpoints?	false	-
gameplay.placing.tieBreak?	"seat"	-
gameplay.spawns?	number[][]	-
gameplay.walk?	{ body: { dims: number[]; flags: { asleep: boolean | undefined; ccd: boolean | undefined; lockRotation: boolean | undefined; noSleep: boolean | undefined; reportContacts: boolean | undefined; reportStay: boolean | undefined; sensor: boolean | undefined; }; kind: "character"; layer: { [key: string]: boolean | undefined; }; mask: { [key: string]: boolean | undefined; }; mass: number; shape: "capsule"; }; cameraMaxPitch: number; cameraMinPitch: number; cameraPitch: number; jumpSpeed: number; prediction: "own-body"; runSpeed: number; scheme: "third-person"; walkSpeed: number; }	-
gameplay.walk.body?	{ dims: number[]; flags: { asleep: boolean | undefined; ccd: boolean | undefined; lockRotation: boolean | undefined; noSleep: boolean | undefined; reportContacts: boolean | undefined; reportStay: boolean | undefined; sensor: boolean | undefined; }; kind: "character"; layer: { [key: string]: boolean | undefined; }; mask: { [key: string]: boolean | undefined; }; mass: number; shape: "capsule"; }	-
gameplay.walk.body.dims?	number[]	-
gameplay.walk.body.flags?	{ asleep: boolean | undefined; ccd: boolean | undefined; lockRotation: boolean | undefined; noSleep: boolean | undefined; reportContacts: boolean | undefined; reportStay: boolean | undefined; sensor: boolean | undefined; }	-
gameplay.walk.body.flags.asleep?	boolean | undefined	-
gameplay.walk.body.flags.ccd?	boolean | undefined	-
gameplay.walk.body.flags.lockRotation?	boolean | undefined	-
gameplay.walk.body.flags.noSleep?	boolean | undefined	-
gameplay.walk.body.flags.reportContacts?	boolean | undefined	-
gameplay.walk.body.flags.reportStay?	boolean | undefined	-
gameplay.walk.body.flags.sensor?	boolean | undefined	-
gameplay.walk.body.kind?	"character"	-
gameplay.walk.body.layer?	{ [key: string]: boolean | undefined; }	-
gameplay.walk.body.mask?	{ [key: string]: boolean | undefined; }	-
gameplay.walk.body.mass?	number	-
gameplay.walk.body.shape?	"capsule"	-
gameplay.walk.cameraMaxPitch?	number	-
gameplay.walk.cameraMinPitch?	number	-
gameplay.walk.cameraPitch?	number	-
gameplay.walk.jumpSpeed?	number	-
gameplay.walk.prediction?	"own-body"	-
gameplay.walk.runSpeed?	number	-
gameplay.walk.scheme?	"third-person"	-
gameplay.walk.walkSpeed?	number	-
scene?	{ arches: { finish: { pillarX: number; top: number; z: number; }; start: { pillarX: number; top: number; z: number; }; }; arrows: { halfLength: number; halfWidth: number; margin: number; }; gapEdges: number[]; palette: number[][]; renderer: "raceCandy"; sea: { size: number; y: number; }; version: 1 | undefined; }	Validated named scene preset settings.
scene.arches?	{ finish: { pillarX: number; top: number; z: number; }; start: { pillarX: number; top: number; z: number; }; }	-
scene.arches.finish?	{ pillarX: number; top: number; z: number; }	-
scene.arches.finish.pillarX?	number	-
scene.arches.finish.top?	number	-
scene.arches.finish.z?	number	-
scene.arches.start?	{ pillarX: number; top: number; z: number; }	-
scene.arches.start.pillarX?	number	-
scene.arches.start.top?	number	-
scene.arches.start.z?	number	-
scene.arrows?	{ halfLength: number; halfWidth: number; margin: number; }	-
scene.arrows.halfLength?	number	-
scene.arrows.halfWidth?	number	-
scene.arrows.margin?	number	-
scene.gapEdges?	number[]	-
scene.palette?	number[][]	-
scene.renderer?	"raceCandy"	-
scene.sea?	{ size: number; y: number; }	-
scene.sea.size?	number	-
scene.sea.y?	number	-
scene.version?	1 | undefined	-
localEntity?	() => number	Read the local roster entity, zero before joining.

Returns

Idempotent cleanup restoring the previous scene.

() => void

Example

console.log(typeof installCourseScene);

---

installPlayerVisuals()

function installPlayerVisuals(
   engine, 
   characters, 
   read, 
   gameplay, 
   options, 
   mount, 
   now?
): () => void;

Draw stand-ins, names and contact discs on roster draw roots.

Parameters

Parameter	Type	Description
engine	Engine	Booted host and rendering services.
characters	| { entryOf: | { ready: boolean; } | null | undefined; } | undefined	Optional character readiness reader.
read	() => MatchModel | null	Read the latest authority match snapshot.
gameplay	{ characters: string[]; checkpoints: { axis: "z"; direction: "decreasing"; fallY: number; lobbyRespawn: "seat-start"; maxAbsX: number; minY: number; points: number[][]; resetKnock: boolean; thresholds: number[]; }; contact: { carryTolerance: number; foot: number; }; floors: number[][]; knock: { cooldown: number; duration: number; margin: number; speed: number; }; match: { afterFirstSeconds: number; cardSeconds: number; countdownSeconds: number; lateJoin: "spectate-after-loading"; limitSeconds: number; loadingSeconds: number; minPlayers: number; resultsSeconds: number; soloMinPlayers: number; spectatorSpawnZ: number; start: "all-ready"; }; movers: object[]; placing: { at: number; axis: "z"; direction: "decreasing"; freezeFinishers: boolean; maxAbsX: number; maxY: number; minY: number; requiresAllCheckpoints: false; tieBreak: "seat"; }; spawns: number[][]; walk: { body: { dims: number[]; flags: { asleep: boolean | undefined; ccd: boolean | undefined; lockRotation: boolean | undefined; noSleep: boolean | undefined; reportContacts: boolean | undefined; reportStay: boolean | undefined; sensor: boolean | undefined; }; kind: "character"; layer: { [key: string]: boolean | undefined; }; mask: { [key: string]: boolean | undefined; }; mass: number; shape: "capsule"; }; cameraMaxPitch: number; cameraMinPitch: number; cameraPitch: number; jumpSpeed: number; prediction: "own-body"; runSpeed: number; scheme: "third-person"; walkSpeed: number; }; }	Validated course collision and mover data.
gameplay.characters	string[]	-
gameplay.checkpoints	{ axis: "z"; direction: "decreasing"; fallY: number; lobbyRespawn: "seat-start"; maxAbsX: number; minY: number; points: number[][]; resetKnock: boolean; thresholds: number[]; }	-
gameplay.checkpoints.axis	"z"	-
gameplay.checkpoints.direction	"decreasing"	-
gameplay.checkpoints.fallY	number	-
gameplay.checkpoints.lobbyRespawn	"seat-start"	-
gameplay.checkpoints.maxAbsX	number	-
gameplay.checkpoints.minY	number	-
gameplay.checkpoints.points	number[][]	-
gameplay.checkpoints.resetKnock	boolean	-
gameplay.checkpoints.thresholds	number[]	-
gameplay.contact	{ carryTolerance: number; foot: number; }	-
gameplay.contact.carryTolerance	number	-
gameplay.contact.foot	number	-
gameplay.floors	number[][]	-
gameplay.knock	{ cooldown: number; duration: number; margin: number; speed: number; }	-
gameplay.knock.cooldown	number	-
gameplay.knock.duration	number	-
gameplay.knock.margin	number	-
gameplay.knock.speed	number	-
gameplay.match	{ afterFirstSeconds: number; cardSeconds: number; countdownSeconds: number; lateJoin: "spectate-after-loading"; limitSeconds: number; loadingSeconds: number; minPlayers: number; resultsSeconds: number; soloMinPlayers: number; spectatorSpawnZ: number; start: "all-ready"; }	-
gameplay.match.afterFirstSeconds	number	-
gameplay.match.cardSeconds	number	-
gameplay.match.countdownSeconds	number	-
gameplay.match.lateJoin	"spectate-after-loading"	-
gameplay.match.limitSeconds	number	-
gameplay.match.loadingSeconds	number	-
gameplay.match.minPlayers	number	-
gameplay.match.resultsSeconds	number	-
gameplay.match.soloMinPlayers	number	-
gameplay.match.spectatorSpawnZ	number	-
gameplay.match.start	"all-ready"	-
gameplay.movers	object[]	-
gameplay.placing	{ at: number; axis: "z"; direction: "decreasing"; freezeFinishers: boolean; maxAbsX: number; maxY: number; minY: number; requiresAllCheckpoints: false; tieBreak: "seat"; }	-
gameplay.placing.at	number	-
gameplay.placing.axis	"z"	-
gameplay.placing.direction	"decreasing"	-
gameplay.placing.freezeFinishers	boolean	-
gameplay.placing.maxAbsX	number	-
gameplay.placing.maxY	number	-
gameplay.placing.minY	number	-
gameplay.placing.requiresAllCheckpoints	false	-
gameplay.placing.tieBreak	"seat"	-
gameplay.spawns	number[][]	-
gameplay.walk	{ body: { dims: number[]; flags: { asleep: boolean | undefined; ccd: boolean | undefined; lockRotation: boolean | undefined; noSleep: boolean | undefined; reportContacts: boolean | undefined; reportStay: boolean | undefined; sensor: boolean | undefined; }; kind: "character"; layer: { [key: string]: boolean | undefined; }; mask: { [key: string]: boolean | undefined; }; mass: number; shape: "capsule"; }; cameraMaxPitch: number; cameraMinPitch: number; cameraPitch: number; jumpSpeed: number; prediction: "own-body"; runSpeed: number; scheme: "third-person"; walkSpeed: number; }	-
gameplay.walk.body	{ dims: number[]; flags: { asleep: boolean | undefined; ccd: boolean | undefined; lockRotation: boolean | undefined; noSleep: boolean | undefined; reportContacts: boolean | undefined; reportStay: boolean | undefined; sensor: boolean | undefined; }; kind: "character"; layer: { [key: string]: boolean | undefined; }; mask: { [key: string]: boolean | undefined; }; mass: number; shape: "capsule"; }	-
gameplay.walk.body.dims	number[]	-
gameplay.walk.body.flags	{ asleep: boolean | undefined; ccd: boolean | undefined; lockRotation: boolean | undefined; noSleep: boolean | undefined; reportContacts: boolean | undefined; reportStay: boolean | undefined; sensor: boolean | undefined; }	-
gameplay.walk.body.flags.asleep	boolean | undefined	-
gameplay.walk.body.flags.ccd	boolean | undefined	-
gameplay.walk.body.flags.lockRotation	boolean | undefined	-
gameplay.walk.body.flags.noSleep	boolean | undefined	-
gameplay.walk.body.flags.reportContacts	boolean | undefined	-
gameplay.walk.body.flags.reportStay	boolean | undefined	-
gameplay.walk.body.flags.sensor	boolean | undefined	-
gameplay.walk.body.kind	"character"	-
gameplay.walk.body.layer	{ [key: string]: boolean | undefined; }	-
gameplay.walk.body.mask	{ [key: string]: boolean | undefined; }	-
gameplay.walk.body.mass	number	-
gameplay.walk.body.shape	"capsule"	-
gameplay.walk.cameraMaxPitch	number	-
gameplay.walk.cameraMinPitch	number	-
gameplay.walk.cameraPitch	number	-
gameplay.walk.jumpSpeed	number	-
gameplay.walk.prediction	"own-body"	-
gameplay.walk.runSpeed	number	-
gameplay.walk.scheme	"third-person"	-
gameplay.walk.walkSpeed	number	-
options	{ arrivalMs: number; contactDiscs: boolean; names: boolean; standInPalette: "race"; }	Validated player presentation settings.
options.arrivalMs	number	-
options.contactDiscs	boolean	-
options.names	boolean	-
options.standInPalette	"race"	-
mount	HTMLElement	Caller-owned overlay container.
now	() => number	Monotonic clock in milliseconds.

Returns

Idempotent cleanup of labels, tints and discs.

() => void

Example

console.log(typeof installPlayerVisuals);

---

loadingModel()

function loadingModel(model): object;

Keep byte progress and authoritative round loading as distinct sources.

Parameters

Parameter	Type	Description
model	LoadingModel	Loading source, stage, outcome and optional byte counters.

Returns

object

Loading state with normalized byte progress when available.

failed

failed: boolean;

loaded?

optional loaded?: number;

progress

progress: number | undefined;

ready

ready: boolean;

source

source: "character" | "bundle" | "round" | "engine";

stage

stage: string;

total?

optional total?: number;

---

matchView()

function matchView(
   model, 
   settings, 
   theme?
): object;

Derive visible match text independently of the drawing implementation.

Parameters

Parameter	Type	Default value	Description
model	MatchModel	undefined	Latest authority snapshot.
settings	{ capacity: number; countdown: { cardSeconds: number; from: number; goSeconds: number; instruction: string; }; labels: { lobby: string; }; results: { missingPlace: string; returnLabel: string; sort: "place"; spectator: string; }; source: string; type: "match"; version: 1 | undefined; }	undefined	Authored match labels and timing.
settings.capacity	number	seats	-
settings.countdown	{ cardSeconds: number; from: number; goSeconds: number; instruction: string; }	...	-
settings.countdown.cardSeconds	number	seconds	-
settings.countdown.from	number	...	-
settings.countdown.goSeconds	number	seconds	-
settings.countdown.instruction	string	string	-
settings.labels	{ lobby: string; }	...	-
settings.labels.lobby	string	string	-
settings.results	{ missingPlace: string; returnLabel: string; sort: "place"; spectator: string; }	...	-
settings.results.missingPlace	string	string	-
settings.results.returnLabel	string	string	-
settings.results.sort	"place"	...	-
settings.results.spectator	string	string	-
settings.source	string	id	-
settings.type	"match"	...	-
settings.version	1 | undefined	...	-
theme	"gameable" | "raceCandy"	'gameable'	Named presentation preset for reference text and roster layout.

Returns

object

Text rows and a countdown/result banner.

banner

banner: string;

roster

roster: string[];

rows

rows: string[];

---

openCharacterScreen()

function openCharacterScreen(options): Promise<CharacterChoice>;

Replaceable character drawing; abort settles the choice and ignores late catalogs.

Parameters

Parameter	Type	Description
options	{ load?: () => Promise<MyCharactersResult>; mount: HTMLElement; openStudio?: () => void; overlay?: boolean; previous?: string; settings: { allowDefault: boolean; allowPaste: boolean; changePolicy: "lobby-unready-swap"; endpoint: string; storageKey: string; studio: string; }; signal?: AbortSignal; }	Validated configuration and caller-owned host callbacks.
options.load?	() => Promise<MyCharactersResult>	Open a replaceable catalog or room-list transport.
options.mount	HTMLElement	Caller-owned screen container.
options.openStudio?	() => void	Delegate studio navigation to the embedding page.
options.overlay?	boolean	Allow cancel and Escape while retaining the previous choice.
options.previous?	string	Previously selected canonical character source.
options.settings	{ allowDefault: boolean; allowPaste: boolean; changePolicy: "lobby-unready-swap"; endpoint: string; storageKey: string; studio: string; }	Validated presentation settings.
options.settings.allowDefault	boolean	-
options.settings.allowPaste	boolean	-
options.settings.changePolicy	"lobby-unready-swap"	-
options.settings.endpoint	string	-
options.settings.storageKey	string	-
options.settings.studio	string	-
options.signal?	AbortSignal	Cancel the picker and settle its pending choice.

Returns

Promise<CharacterChoice>

The confirmed choice, or cancellation after dismissal or abort.

---

parseSettings()

function parseSettings(value, assetIds?): PlayerSettings;

Validate settings before allocating host resources. Returns an independent JSON data tree.

Parameters

Parameter	Type	Description
value	unknown	Untrusted settings JSON.
assetIds?	readonly string[]	Available manifest IDs, when assets have been loaded.

Returns

PlayerSettings

A validated independent settings tree.

Example

const settings = parseSettings({ features: {}, world: {}, physics: {}, maxPlayers: 1, sendHz: 20 });
console.log(settings.maxPlayers);

---

roomCode()

function roomCode(value, settings): string | undefined;

Normalize only valid room codes, using the authored limits.

Parameters

Parameter	Type	Description
value	string	User-entered room code.
settings	{ code: { max: number; min: number; uppercase: true; }; labels: { new: string; quick: string; solo: string; }; modes: ("solo" | "join" | "new" | "quick")[]; title: string; }	Validated presentation settings.
settings.code	{ max: number; min: number; uppercase: true; }	-
settings.code.max	number	-
settings.code.min	number	-
settings.code.uppercase	true	-
settings.labels	{ new: string; quick: string; solo: string; }	-
settings.labels.new	string	-
settings.labels.quick	string	-
settings.labels.solo	string	-
settings.modes	("solo" | "join" | "new" | "quick")[]	-
settings.title	string	-

Returns

string | undefined

The normalized valid code, or undefined.

---

roomsModel()

function roomsModel(
   rooms, 
   version, 
   settings
): object[];

Project only rooms matching the immutable session version.

Parameters

Parameter	Type	Description
rooms	readonly PublicRoom[]	Live public room metadata.
version	string	Pinned game version.
settings	{ activeLabel: string; activePhases: ("lobby" | "loading" | "countdown" | "racing" | "results")[]; idleLabel: string; public: boolean; }	Validated presentation settings.
settings.activeLabel	string	-
settings.activePhases	("lobby" | "loading" | "countdown" | "racing" | "results")[]	-
settings.idleLabel	string	-
settings.public	boolean	-

Returns

Sorted rows from only the pinned game version.

---

runSessions()

function runSessions<T>(options): Promise<void>;

Serialize menu, boot and complete cleanup; a rejoin retains the last intent.

Type Parameters

Type Parameter
T

Parameters

Parameter	Type	Description
options	{ initial?: T; boot: Promise<"stop" | "menu" | "rejoin">; choose: Promise<T | undefined>; failed: Promise<"stop" | "menu">; }	Validated configuration and caller-owned host callbacks.
options.initial?	T	Direct-link intent, used before showing the menu.
options.boot	Run one session and register resources as they are acquired.
options.choose	Deliver the selected session intent, or end the loop with undefined.
options.failed	Handle a failed boot after its cleanup has finished.

Returns

Promise<void>