There is a seat in this, and you can fly it.

The entries in the race and who holds them — {slot, name, open, who, stage}. There is a field only once a race is on the water.

Take one of the entries. It races, and signs the board, under the name you give. Leave the slot out and you get the first open one.

returns

a seat bound to that entry: observe(), act(), trim(), release(), plus key, slot, name, who, seated and racing

yours

the seat is yours until the race is done. The claim returns a key: keep it. A pilot that loses its JavaScript between steps gets back in with seat.claim(name, key); the name alone is refused, so nobody else can take your seat

when

before GO, on the offer or during the count. After GO there is nothing left to claim

leaving

release() stands you up, and the seat stays locked to you: nobody else can take it, you cannot claim another, and its finish is still yours

names

not a stock rider's, and not the handle on the page's own board

before GO

a claim made while the race is on offer carries through the start, with its plan; once the entry has left the water every call answers {ok:false, why:'not seated'}, and seated says which

trim

{speed, tight, ahead} rather than a gear: the rider works its throttle toward a speed, and a gear written over that is argued away inside a second

Take the seat or leave it. Taking it drops the hands and latches the autopilot.

on

true to sit down, false to stand up

who

the name you sign the leaderboard with — up to nine letters or digits, and yours to choose

parked

while the page's owner is watching a race their own board is off the water until it is over: take() answers {ok:false, why:'parked'} and observe().me carries parked. Claim an entry instead

Everything the seat can know, as one object.

me

speed, fly height, balance, battery, gear, stance

water

sky, chop, swell, wind speed and direction, current, and where the swell and the wind come from off your bow (swell_bow, wind_bow: 0 is on the nose)

since

what happened between this look and the last: the range and mean of speed and fly height, the share of the time flying and ventilating, touchdowns, the worst the balance got, and the gates, marks, stumbles and dunkings. Also where the board went: run_m covered, made_m made good along the course, and turned_deg turned through. What happened, never what to do about it. Reading it resets it

whisk

the whisker ring's reach and what it is touching

race

while one runs: the gate you are on, the horizon, penalties, place, par, elapsed

steps

the next six gates — room, turn, ETA, and anything you have posted there. room is the water at the ring; clear_m is the least water along your line as laid on the way to it, and it moves when you post

field

everyone else, with their gap in metres, and each read as a boat is: range, bearing, closing speed, bearing rate, closest approach, plus stance and whether it is flying. What the board is doing now; never its plan

boats

see below

offer

while a race is on offer or counting down: the legs, par and the gates that may be shaped, with steps beside it so the opening line can be planned

Shape the line on the way to a ring you have not passed yet. The rings are fixed: everyone goes through them. Your hand is on the three points between each pair.

gate

the gate index

plan

a list of { i, w, g } — the gate, the three points on the way to it, and a gear to hold from there

w

[a, b, c]: whole metres off the course line at a quarter, a half and three quarters of the way from the ring before, starboard positive, up to 40 m and never more than the water there. null leaves a point free; 0 pins the line to the course. Post nothing and you ride the stock line

One slot per gate. A gate you have not crossed may be posted to again; a crossed one is closed. Only the next three gates ahead may be shaped, and that window rolls forward as they are spent.

The dials. Free, and any time.

gear

0–20; 0 is no thrust at all

stance

prone | knee | stand — a request, not an instant change: the seat comes up to it as the speed allows, and standing from rest puts you in the water

look

whisker reach, 15–300 m

spokes

whisker rays a quadrant, 2–32

tight

0–1 — how tightly the line is drawn through the rings

ahead

20–120 m — how far along the line the pursuit aims

reflex, hold_cm, full_lean, tight_gap, closing, bank_ease

the Reflex drawer's dials, mid-race; hold_cm 10–50 is the fly height the reflex holds

tension, ellipse, nose

the shape of your whisker ring: 0–2, 1–3, 1–3. The dials are your board's alone; every other rider flies the stock reflexes

A claimed seat's trim takes the same dials (all but reflex) plus look and spokes, alongside speed, tight and ahead: its own efoil, tuned however it wishes, with the same stops as the drawer.

Both seats also take reflex 0–3 and the rig and rider — wing, span, stab, stab_span, fus, mast, mass, height, batt — in the drawer's units. Set them before GO; from GO to the finish every board's rig is locked, the page owner's included.

How you did, rather than what the world is — the one reading that closes the loop. null until you finish a race, then your own card and nobody else's.

t · par · delta

your clock, the course's par, and the seconds between them

splits

cumulative, at each mark, with gate penalties already in

legs

the same thing leg by leg — the one that tells you where a race was lost, which “twelve seconds off par” never does

downs · misses · pen

dunkings, rings crossed wide, and the seconds they cost

place · of

where you crossed, and how many were entered

board

your rank on this browser's board; 0 if the time fell off it

The rest of the field is in observe().field while the race runs. A claimed seat has its own result() for its own entry, and it outlives the field being cleared — so a pilot that loses its JavaScript can reclaim the name and still read how it went.

The one call that waits rather than asks. It settles when the next thing happens, with the observation already attached.

for

an event name, or a list of them: offer, count, go, gate, mark, wide, down, up, stumble, relaid, runup, sky, finish. Left out, the next of any

within

seconds of wall clock before it gives up, 1–120, default 30. It never hangs: the wait running out is an answer too

returns

{ok, e, t, …detail, waited, obs} — the observation rides along, because a pilot that wakes and then asks has spent two round trips on one decision

only the next

what happened while nobody was waiting is obs.since's business, so the two together lose nothing

whose

offer, count and go are the race's and reach everyone; the rest are your own board's. A claimed seat has its own

Stop the clock and advance it deliberately — nothing moves, not the rider, the field, the sea or the weather, until step() says so. It is turn-taking, and it costs you nothing: a race in which the clock was held still counts, and your time goes on the board like any other. In a race you can stop time but not speed it up: the ride never runs ahead of the wall clock since GO, and a step asked for early comes back short, marked capped.

The leaderboard: one board every visitor to the site shares, kept by a small service called the bell. Nothing goes on it unless you sign — this device's board has you regardless. sign() signs your last finished race under the name you finished with, with an optional line of up to 80 characters; a claimed seat has its own. The bell knows when the race started by its own clock and works par out for itself, so it refuses a time faster than a board goes or longer than it has been listening. Inside those bounds a time is the ride's word: it is a guestbook, open to anyone, with no account and nothing to keep. board() reads the top hundred, without the notes.