The board: StarScript’s runtime in a page

this page as plaintext

A board is a starboard/1 stack in a page. The build lays its cards out (star-web/src/board.rs: positioned HTML, an SVG of its links, one column under 40rem), and the runtime (star-web/src/board_rt/, embedded in staros and copied into the site’s media/board-rt/<hash>/) makes it a camera you walk and Play. StarScript is the language of its cards’ scripts; this page is the machinery that runs them, read from its own sources.

Try it

Three cards, editable here. Press Play and pick a way; open Bench in the bar for the play from the inside (the script with the next line marked, the values kept, the tells, the events the cards answer); press Edit, double-click a card and press Graph for its script as a flow. An edit stays in this browser as a draft; Take downloads the stack.

Skip the board

A value kept

A pick keeps mood; a branch reads it. Edit, double-click this card, then Graph.

Start here

Press Play, then Bench in the bar: the play’s script, the values it keeps, its tells.

A tell, an event

A tell goes out to the page; on.ping answers the button under the board, and the bench’s values show it.

The block

[[board: <id> | w=640]] — a starboard canvas stack as a fluid positioned board up to w px wide (cards + link arrows; one column under 40rem). w=fill (2026-11-04): no max width, the board takes its container’s width; edit=1: the runtime mounts its editor on it (move, resize, words, script, a new card, the take as starboard/1). Reads <site>/data/boards/<id>.json (written by staros web ingest-board); missing = a build error naming the fix. A card’s media (src, poster, strip, each stem’s src) must be a file under the site’s media/, or the build fails here rather than shipping a broken card. CSS inlines once.

The viewer

The web board’s viewer (B1, 2026-10-13): turns each [[board]] on the page into a canvas you can move around and play.

Without this script the board is star-web’s static layout, fluid, in reading order, one column under 40rem. With it, a board at least 40rem wide becomes a camera over the cards at their own size: drag to pan; Ctrl or ⌘ with the wheel (or a trackpad pinch) to zoom, so the page still scrolls under a plain wheel; two fingers to pinch and pan on a touch screen, where one finger still scrolls the page. Full screen (any width, the phone’s way in) gives one finger to the board. Tab walks the cards in reading order, framing each; arrows pan, + and - zoom, 0 fits, F toggles full screen. A link to #c-<card id> frames that card. Play runs the cards’ scripts through the stepper ported from starboard (stepper.js) and shows them in the play panel (play.js).

State is on the board’s element for tests and styles: data-sb-mode (static|live|full), data-sb-scale, data-sb-active (the playing card).

mountBoard

mountBoard(wrap)

One board brought to life: wrap a .sb-wrap holding its .sb-board and its .sb-data (every board on the page at import; a page that builds its board itself, StarBoard on the web, 2026-11-06, calls it after). A wrap is mounted once. Returns the viewer, or null when the board stays static.

rust-shared/star-web/src/board_rt/viewer.js:435

The events

A board and the page it is on talk by DOM events on the board’s wrapper (.sb-wrap); they bubble.

event way detail when
sb-tell out {to, what} a script’s set tell.<to> "<what>", as Play runs it
sb-event in {name, words} sent by the page: runs label on.<name> on every card that has one while the board plays (dropped when it does not)
sb-change out {src} the editor’s every change (edit=1): the stack as it stands, starboard/1

A button sends sb-event with no script of its own: <button data-sb-event="<name>" data-sb-words="k=v …" data-sb-board="<the board's id>">. StarScript’s page runs both bridges on boards of its own.

The editor

The web board’s editor (2026-11-04): on a board whose block says edit=1, an Edit toggle in the bar turns the camera into a canvas you arrange. Drag a card to move it (snapped to ten units; Shift moves it freely), drag its corner to resize it, double-click it for its words, its script, its colour and its layer; + Card makes a new one, Delete removes one (and its links). Take downloads the stack as <id>.stack.json, the app’s own shape (starboard/1), and the page raises sb-take on the board’s wrapper first. While you edit, a draft is kept in this browser (localStorage, sb-draft:<id>, written only after the first change); Discard draft forgets it.

The words preview as plain markdown (headings, paragraphs, bold, code, links); the build renders the real thing. A script is parsed as it is typed (script.js, the port of the build’s parser, 2026-11-05): Play runs the new one the next time it enters the card, and a script the grammar refuses shows the Lua’s words under it. Bench, in the bar beside Play (2026-11-06), opens the StarScript bench (bench.js): the play’s script, values, tells and events beside the board, Step and breakpoints with them. Undo and Redo (2026-11-09; history.js): every change is a step (a move, a resize, a card added or removed, a link, a colour, a layer, the words or script typed, the typing into one field as one step); Ctrl+Z takes one back, Ctrl+Y or Ctrl+Shift+Z brings it again, with the bar’s Undo and Redo, while the board itself has the keys (a field keeps its own). More than one card (2026-11-09): Shift and a click adds a card to the selection (or takes it out); Shift and a drag from an empty place draws a band, and every card it touches is selected; a drag on a selected card moves them all; Delete removes them all; the arrows nudge them by ten units (Shift: a hundred); Ctrl+G makes them a group (the stack’s group_id, which the desktop reads), so a press on one of them takes the whole group; Ctrl+Shift+G parts it; Esc clears the selection. Links (2026-11-09): the one selected card shows a port at its right edge; drag it onto another card and the link is written (the inspector’s list adds and removes them too, and gives each its label, drawn at the line’s middle). The jumps a script makes to other cards (goto c-…, a choice, a branch’s arms) are drawn dashed: Play follows them though the stack writes no link. Files and links dropped on the board (2026-11-09; drop.js): a picture becomes an image card at the drop point (kept in the stack as a data URI, scaled to 1600 px), any other file a card of its kind named for it, a link a text card that links to it; dropped on a card, a file swaps that card’s source; while Play waits on a request_file, the drop answers it. + File in the bar opens the picker, for a phone. Find (2026-11-09; find.js, fetched on the first Ctrl+F): the cards whose words or script hold what is typed, the first framed and selected as you type; Enter the next, Shift+Enter back, Esc closes. The keys, while editing and the board itself has them: Ctrl+Z, Ctrl+Y / Ctrl+Shift+Z, Ctrl+F, Ctrl+G and Ctrl+Shift+G, Delete, the arrows (Shift: ten times), Esc; a field keeps its own. The viewer’s stay: arrows pan with nothing selected, + and − zoom, 0 fits, F full screen. The viewer imports this module only for an editable board, so a reader never fetches it.

board_rt/history.js

The editor’s undo and redo (2026-11-09): a history of the stack’s states, each a snapshot of the whole stack as JSON (a stack is kilobytes; a diff would buy nothing here). Every change the editor makes goes through Editor.changed(), which records the state after it, so a move, a resize, a card added or removed, a link, a colour, a layer and the words or script typed are all steps. Typing coalesces: records with the same key within WINDOW milliseconds replace the step they follow, so Undo takes back the whole of what was typed into a field, not a character. Undo and Redo give back the snapshot to lay over the board; a record while standing in the past drops the future, as every editor does. DOM-free: tests/board_rt/history.test.mjs holds it. The editor imports this module, so a reader never fetches it.

History, held by tests/board_rt/history.test.mjs:

The bench

The StarScript bench (2026-11-06): a play’s insides beside the board, as StarBoard’s desktop play pane shows them (starboard/editor/play_panel.lua, “stepthrough + KV watch”). On an editable board, Bench in the bar opens it. While Play runs it shows the card being played and its script, the next command marked (a press on a line’s number sets a breakpoint there: Play stops before it); Step (one command) and Continue (past a breakpoint, on to the next line); the values the play keeps, the ones its last move changed marked; the tells it raised; the events its cards answer, each fired from here as the page’s bridge fires it (sb-event), or any event by name; and the trace. It reads the stepper. Only Step, Continue, a breakpoint and an event change a play. The editor fetches this module on the first press of Bench (a reader never does).

board_rt/bench.js’s parts, the pure ones held by tests/board_rt/bench.test.mjs:

The graph

The graph pane (X4 and X5 of the visual language, 2026-11-06): a card’s script drawn as its flow under the editor’s Script field, and edited there. A cluster (a label and the commands under it) is a column on a wide screen and stacks on a narrow one. A command is a button (44 px on a touch screen), and a jump is a path to the label it lands on (a jump to a card names the card). Every edit is a splice of the script’s text (splice.js) written into the Script field, with that field’s input event, so the editor parses, keeps and redraws as if it were typed. Undo and Redo walk the pane’s own edits. Press a command to select its line in the field. Then ↑ and ↓ move it, ✕ removes it, the palette adds a command after it (the grammar’s own lines, script.js’s VERBS), a jump is pointed at another label or card, and a label is renamed everywhere. The lint marks a jump to no label, a label defined twice (the later wins), a label nothing reaches, and a hold (say, ask, request_file) under a handler (closeCard, onClick, on.), which runs with no holds on both machines: the hold stops it and is never shown. The nodes are buttons rather than the note’s SVG groups: focusable and pressable as they are. The rest of X5 (2026-11-09, the budget ruled by path): the palette follows the pin: after a say or a choice it offers a choice first, after an end a label, and under a handler (closeCard, onClick, on.) no hold at all, since a handler cannot hold; it also offers the tells the page answers (set tell.world "meteor", set tell.page "…") and an on.<event> label. The simulator strip (Dry run) walks this card’s script with a second walker whose tells are collected and shown, never dispatched (a visitor’s dry run must not strike the crater): the lines it would speak (the first choice taken, an ask answered with …), the values kept, the card it leaves for. The editor fetches this module on the first press of Graph.

board_rt/graph.js

A card’s script as a flow graph (X3 of the visual language, 2026-11-06): a port of love-shared’s dialogue_graph.lua, the model StarStage’s flow_graph and the desk’s Scratch draw. Clusters part the commands at every label (an _entry cluster holds the ones before the first, dropped when empty). Edges are each command’s successors: seq, goto, choice, branch_yes, branch_no, when_keep, when_skip, wait_ok, wait_to, and card_goto for a jump to a card (a target starting c-, or one of opts.cardIds). Indexes are the Lua’s, 1-based, as the stepper’s cursor and the parser’s labels are. tests/board_rt/splice.test.mjs holds it to splice_cases.json, minted from the Lua.

board_rt/splice.js

A card’s script edited as text (X3 of the visual language, 2026-11-06): a port of love-shared’s dialogue_edit.lua. Every edit the graph makes is a splice of the script’s TEXT and a re-parse, never a graph written back as text: comments, blank lines and the untouched lines’ own spacing survive byte for byte, and a touched command’s line is rebuilt by emitLine, its free text quoted. A command is found by its number (1-based, the parser’s order) through the body’s own lines, since the parser’s line_no does not count blank lines. The Lua’s quirks are kept: - a command moved after itself goes to the end, and an index past the last appends; - rewire rewrites the named word whatever the verb; - the words stop at the first missing one, as Lua’s ipairs does. One difference: setKv matches its key literally, where the Lua reads it as a pattern. That is the same for a key without . - + * ? [ ^ $ % ( ); a key with a hyphen never matches in the Lua, which adds a second token (the M2’s handoff). tests/board_rt/splice.test.mjs holds this file to splice_cases.json, minted from the Lua.

tests/board_rt/splice.test.mjs holds both to splice_cases.json, which mint_splice_cases.py mints from love-shared’s committed dialogue_graph.lua and dialogue_edit.lua; flow.test.mjs holds the lint.

The walker: Stepper

board_rt/stepper.js, a line-for-line port of love-shared’s board/stepper.lua, held to the Lua’s own cases (starboard/tests/stepper_cases.json) by tests/board_rt/stepper.test.mjs. The viewer makes one for each board; a page that walks a stack itself makes its own over {cards, links}, each card with its parsed prog.

constructor

new Stepper(stack, opts)

textOf gives an empty-script card’s text (the Lua reads card.text; the page reads the rendered card, so the JSON need not repeat it). onTell hears THE TELL BRIDGE (2026-11-03): set tell.<to> "<what>" is a plain set (the kv holds it, as the Lua’s does) that also tells the page the board is on: the s2ar home routes tell.world to its world’s act and tell.act to a tool. Every tell raised in a play is kept in order in tells too (the Lua’s stepper.tells, 2026-11-06).

// with `parse` from board_rt/script.js and `Stepper` from board_rt/stepper.js
const r = parse('say s2ar "A line."\nend\n');
const s = new Stepper({ cards: [{ id: 'c-a', x: 0, y: 0, w: 200, h: 100, prog: r.prog }], links: [] });
return { card: s.card_id, finished: s.finished, kv: s.kv };

Gives, held by tests/board_rt/examples.test.mjs:

{
 "card": null,
 "finished": false,
 "kv": {}
}

rust-shared/star-web/src/board_rt/stepper.js:124

findCard

findCard(id)

The stack’s card with that id, or null.

// with `parse` from board_rt/script.js and `Stepper` from board_rt/stepper.js
const s = new Stepper({ cards: [{ id: 'c-a', x: 0, y: 0, w: 200, h: 100 }], links: [] });
return { found: s.findCard('c-a').id, missing: s.findCard('c-zz') };

Gives, held by tests/board_rt/examples.test.mjs:

{
 "found": "c-a",
 "missing": null
}

rust-shared/star-web/src/board_rt/stepper.js:146

setKv

setKv(path, v)

Keeps a value, as set does (a dotted name is a path).

// with `parse` from board_rt/script.js and `Stepper` from board_rt/stepper.js
const s = new Stepper({ cards: [], links: [] });
s.setKv('mood', 'glad');
s.setKv('tell.page', 'a tell');
return { mood: s.getKv('mood'), kv: s.kv };

Gives, held by tests/board_rt/examples.test.mjs:

{
 "mood": "glad",
 "kv": {
  "mood": "glad",
  "tell": {
   "page": "a tell"
  }
 }
}

rust-shared/star-web/src/board_rt/stepper.js:152

getKv

getKv(path)

The value kept at a path, or undefined.

rust-shared/star-web/src/board_rt/stepper.js:154

toggleBreakpoint

toggleBreakpoint(cardId, lineNo)

A breakpoint on a card’s line, on or off: runToSay stops before it.

// with `parse` from board_rt/script.js and `Stepper` from board_rt/stepper.js
const r = parse('set k 1\nsay s2ar "Never reached by run."\nend\n');
const s = new Stepper({ cards: [{ id: 'c-a', x: 0, y: 0, w: 200, h: 100, prog: r.prog }], links: [] });
s.toggleBreakpoint('c-a', 2);
s.start(s.findCard('c-a'));
s.runToSay();
return { stoppedBefore: s.currentCommand().kind, line: s.last_line, isBreakpoint: s.isBreakpoint('c-a', 2) };

Gives, held by tests/board_rt/examples.test.mjs:

{
 "stoppedBefore": "say",
 "line": null,
 "isBreakpoint": true
}

rust-shared/star-web/src/board_rt/stepper.js:157

isBreakpoint

isBreakpoint(cardId, lineNo)

Whether that line has a breakpoint.

rust-shared/star-web/src/board_rt/stepper.js:162

start

start(card)

A new play from that card: the kv, the tells and the history emptied, the card entered at its openCard.

// with `parse` from board_rt/script.js and `Stepper` from board_rt/stepper.js
const r = parse('say s2ar "A line."\nend\n');
const s = new Stepper({ cards: [{ id: 'c-a', x: 0, y: 0, w: 200, h: 100, prog: r.prog }], links: [] });
s.start(s.findCard('c-a'));
s.runToSay();
return { card: s.card_id, kind: s.last_line.kind, said: s.last_line.text, finished: s.finished };

Gives, held by tests/board_rt/examples.test.mjs:

{
 "card": "c-a",
 "kind": "say",
 "said": "A line.",
 "finished": false
}

rust-shared/star-web/src/board_rt/stepper.js:166

canBack

canBack()

Whether a card visited before can be gone back to.

rust-shared/star-web/src/board_rt/stepper.js:284

canForward

canForward()

Whether a card gone back from can be gone forward to again.

rust-shared/star-web/src/board_rt/stepper.js:286

navBack

navBack()

Back to the card visited before (its script entered again); false when there is none.

// with `parse` from board_rt/script.js and `Stepper` from board_rt/stepper.js
const a = parse('say s2ar "A"\nchoice c-b "Go to B"\nend\n'), b = parse('say s2ar "B"\nend\n');
const s = new Stepper({ cards: [{ id: 'c-a', x: 0, y: 0, w: 200, h: 100, prog: a.prog }, { id: 'c-b', x: 300, y: 0, w: 200, h: 100, prog: b.prog }], links: [] });
s.start(s.findCard('c-a'));
s.runToSay();
s.pickChoice(1);
s.runToSay();
const at = s.card_id;
s.navBack();
return { at, back: s.card_id, canForward: s.canForward() };

Gives, held by tests/board_rt/examples.test.mjs:

{
 "at": "c-b",
 "back": "c-a",
 "canForward": true
}

rust-shared/star-web/src/board_rt/stepper.js:289

navForward

navForward()

Forward to the card gone back from; false when there is none.

rust-shared/star-web/src/board_rt/stepper.js:301

currentCommand

currentCommand()

The parsed command the cursor is on, or null.

rust-shared/star-web/src/board_rt/stepper.js:313

step

step()

One statement. Returns “next”, “say”, “ask”, “request_file”, “end” or “error”.

// with `parse` from board_rt/script.js and `Stepper` from board_rt/stepper.js
const r = parse('set k 1\nsay s2ar "x"\nend\n');
const s = new Stepper({ cards: [{ id: 'c-a', x: 0, y: 0, w: 200, h: 100, prog: r.prog }], links: [] });
s.start(s.findCard('c-a'));
return [s.step(), s.step(), s.step()];

Gives, held by tests/board_rt/examples.test.mjs:

[
 "next",
 "say",
 "end"
]

rust-shared/star-web/src/board_rt/stepper.js:328

onClick

onClick(wx, wy)

The active card’s onClick; with none, or after pass, the click bubbles to the topmost background card under the world point (wx, wy).

rust-shared/star-web/src/board_rt/stepper.js:510

fire

fire(event, payload)

An event (StarScript step 4, the Lua’s M:fire): event.name and event.<k> of payload into the kv, then every label on.<event> runs as onClick runs (a say stops it), the active card first, then the stack’s order. handlers that ran

// with `parse` from board_rt/script.js and `Stepper` from board_rt/stepper.js
const r = parse('label openCard\nsay s2ar "Waiting for a ping."\nend\nlabel on.ping\nset pinged yes\nend\n');
const s = new Stepper({ cards: [{ id: 'c-a', x: 0, y: 0, w: 200, h: 100, prog: r.prog }], links: [] });
s.start(s.findCard('c-a'));
s.runToSay();
const handlers = s.fire('ping', { by: 'the page' });
return { handlers, pinged: s.kv.pinged, event: s.kv.event, still: s.last_line.text };

Gives, held by tests/board_rt/examples.test.mjs:

{
 "handlers": 1,
 "pinged": "yes",
 "event": {
  "name": "ping",
  "by": "the page"
 },
 "still": "Waiting for a ping."
}

rust-shared/star-web/src/board_rt/stepper.js:544

commitInput

commitInput(text)

Resolve an ask or request_file hold.

// with `parse` from board_rt/script.js and `Stepper` from board_rt/stepper.js
const r = parse('ask name "Who are you?"\nsay s2ar "Hello, $name."\nend\n');
const s = new Stepper({ cards: [{ id: 'c-a', x: 0, y: 0, w: 200, h: 100, prog: r.prog }], links: [] });
s.start(s.findCard('c-a'));
s.runToSay();
const asked = s.last_line.kind;
s.commitInput('Luna');
s.runToSay();
return { asked, said: s.last_line.text, name: s.kv.name };

Gives, held by tests/board_rt/examples.test.mjs:

{
 "asked": "ask",
 "said": "Hello, Luna.",
 "name": "Luna"
}

rust-shared/star-web/src/board_rt/stepper.js:564

pickChoice

pickChoice(idx)

Apply the player’s pick (1-based, as the Lua).

// with `parse` from board_rt/script.js and `Stepper` from board_rt/stepper.js
const r = parse('say s2ar "Which way?"\nchoice left "Left" set:way=west\nchoice right "Right" set:way=east\nend\nlabel left\nsay s2ar "Heading $way."\nend\nlabel right\nend\n');
const s = new Stepper({ cards: [{ id: 'c-a', x: 0, y: 0, w: 200, h: 100, prog: r.prog }], links: [] });
s.start(s.findCard('c-a'));
s.runToSay();
const offered = s.last_line.choices.map((c) => c.text);
s.pickChoice(1);
s.runToSay();
return { offered, way: s.kv.way, said: s.last_line.text };

Gives, held by tests/board_rt/examples.test.mjs:

{
 "offered": [
  "Left",
  "Right"
 ],
 "way": "west",
 "said": "Heading west."
}

rust-shared/star-web/src/board_rt/stepper.js:576

runToSay

runToSay()

Statements until the next say / ask / request_file, end, error or breakpoint.

// with `parse` from board_rt/script.js and `Stepper` from board_rt/stepper.js
const r = parse('set k 1\nset j 2\nsay s2ar "Both kept."\nend\n');
const s = new Stepper({ cards: [{ id: 'c-a', x: 0, y: 0, w: 200, h: 100, prog: r.prog }], links: [] });
s.start(s.findCard('c-a'));
s.runToSay();
return { said: s.last_line.text, k: s.kv.k, j: s.kv.j };

Gives, held by tests/board_rt/examples.test.mjs:

{
 "said": "Both kept.",
 "k": "1",
 "j": "2"
}

rust-shared/star-web/src/board_rt/stepper.js:599

stop

stop()

Ends the play where it stands.

rust-shared/star-web/src/board_rt/stepper.js:613

dismiss

dismiss()

Leaves the card: no card, no line, the cursor at the top (the kv kept).

rust-shared/star-web/src/board_rt/stepper.js:619

The helpers

The data

What the runtime needs beyond the HTML (B1): the board’s frame, each card’s box, layer and parsed script (never its text: the runtime reads the card itself), the links, and the card Play starts on. JSON in a data block, escaped for a script body. The fields:

The work on this page: the commits of the last 30 days on its sources, the work open against them, its checks

  • rust-shared 1495b28 star-web: the work record's types and its two blocks, [[timeline:]] and [[work:]]; a lint for a block marker left as words (2026-11-10)

  • rust-shared 628a038 board: a live card carries its script's text (2026-11-09)
  • rust-shared 1ad0b7c board_rt flow: X5's rest: the palette follows the pin, and a dry run with its tells collected (2026-11-09)
  • rust-shared 0de8c8d board_rt tests: the reference's examples for the walker and the parser, each run and held to what it returns (2026-11-09)
  • rust-shared 433a4c0 board_rt: find in the cards (find.js) on Ctrl+F; the editor's keys named (2026-11-09)
  • rust-shared 162cb25 board_rt: files and links dropped on the board (drop.js), + File in the bar (2026-11-09)
  • rust-shared 75e6c10 board_rt edit, board: links dragged from a port, their labels drawn, the jumps a script implies dashed (2026-11-09)
  • rust-shared a954b83 board_rt edit: more than one card: Shift-click and a band select, a drag moves them all, Delete, the arrows, groups (2026-11-09)
  • rust-shared de5edbb board_rt: undo and redo in the editor (history.js), and the runtime's budgets by path (2026-11-09)
  • rust-shared ead547a board_rt flow: the lint marks a hold under a handler, and closeCard is a hook (2026-11-09)

  • rust-shared 99bc3b1 star-web blocks: the reference's search: a page's first tree carries the search module's tag where the site has it (2026-11-08)

  • rust-shared 60ae9a4 star-web board runtime: X4 and X5, the graph pane: a card's script drawn as its flow and edited there, every edit a splice of its text (2026-11-06)
  • rust-shared 7325f04 star-web board runtime: X3, the flow graph and the splices in the page, byte for byte against love-shared's (2026-11-06)
  • rust-shared 3d6d32e star-web board runtime: the StarScript bench, a play's insides beside an editable board, as StarBoard's desktop play pane shows them (2026-11-06)
  • rust-shared 7bc2b8c star-web board editor: a new card takes the free place nearest the view's middle, never another card's (2026-11-06)
  • rust-shared 47f668c star-web board runtime: each of the walker's public methods says what it does, the words the reference's board page reads (2026-11-06)
  • rust-shared 5b971f6 star-web board runtime: the event bridge, the tell bridge's other half: a page's `sb-event` fires `label on.<event>` while Play runs, and a plain button sends one (StarScript step 4's host contract, 2026-11-06)
  • rust-shared 6109128 star-web board runtime: StarScript steps 3 and 4 from the M2: `when … gt|lt` compares as numbers, and an event fires `on.<event>` handlers (the M2's handoff, 2026-11-06)
  • rust-shared dfb8a86 star-web board runtime: its doc comment names the stepper's new home (love-shared board/stepper.lua) and its set:k=v and tells (2026-11-06)
  • rust-shared 9f1fa70 star-web board runtime: the stepper follows the M2's two new cases: a choice's set:k=v pairs written on its pick, and every tell kept in order (the M2's handoff, 2026-11-06)
  • rust-shared 62fcc82 star-web board runtime: mountBoard for a page that builds its board itself, Play on every editable board, the editor's changes announced, links edited in the inspector (StarBoard on the web, 2026-11-06)

  • rust-shared c91f31a star-web tests: the board runtime's node tests run by a glob (Node 22+ no longer runs a bare folder), the headers say so (2026-11-05)
  • rust-shared 72ab480 star-web board runtime: two budgets, a reader's modules under 64 KiB and the whole runtime under 144 KiB (X2 of the visual language, 2026-11-05)
  • rust-shared d0e93ca star-web: a block marker inside <code> or <pre> is the syntax a page shows, never a block (2026-11-05)
  • rust-shared 0e28e98 star-web board runtime: script.js, StarScript parsed in the browser, so an edited card runs without a rebuild; the parse cases minted from the Rust (X1 of the visual language, 2026-11-05)
  • rust-shared 4585e77 star-web: the [[view:]] block (the reference's live examples) and the [[nav:]] block (its tree, collapsed, the left pane); D2 of the reference lane (2026-11-05)
  • rust-shared 57890a0 star-web: the world block mounts the VERSIONED twin the staged manifest names (D0 of the reference lane, 2026-11-05)
  • rust-shared d77deee star-web: the shell's nav a drawer under 40rem (a checkbox's label, no script), viewport-fit=cover, the board's buttons a thumb's width (2026-11-05)
  • rust-shared 49a2364 star-web board runtime: a full-screen board frames its card again when the play panel's height settles

  • rust-shared ffd8f9d star-web board editor: a deleted card leaves the viewer's card list in place (the stepper holds that very array)
  • rust-shared 660a37d star-web board: w=fill (the board takes its container's width), edit=1 (an editor in the runtime: move, resize, words, script, a new card, the take as starboard/1), Play beside a wide board

  • rust-shared 7cd14d3 star-web board runtime: the tell bridge: a set on tell.<to> is a plain set that also tells the page (2026-11-03, the tower; H3 of the planet home)

  • rust-shared e7a499a star-web/tests: cdp.mjs, the one headless-Chrome client; the board e2e on it (K3 of Track D)

  • rust-shared bda6cf2 star-web: the studio's render says which file each figure is (data-media), so the canvas can hand one to its pin
  • rust-shared 5dbb876 star-web board: a world card links its cart's player page (/play/<record>; M4 of the cartridge program) — the importer's `play`, rendered only in that one shape
  • rust-shared 04352c3 star-web: a figure zooms, a clip loops, full is wider than wide, small images keep their width, inlined ones are checked
  • rust-shared 89acd17 star-web: the [[world:]] marker (M3 of the cartridge program) — a StarLab world a visitor runs on the reference sim in the page: the cart from the site's data/carts.json (by name or by its scene), the figure the platform builder renders (the witness in the caption, a slot, the control; a refused world states why), the runtime's tags (world_rt::script_tag) for a page that counts one; a missing index, cart or runtime refuses the build by name
  • rust-shared f6dd84c star-web: unnumbered margin figures (size=margin) and figure ids

  • rust-shared 67652ed star-web: an essay's figures and clips (the pinboard's site half): [[figure:]], sizes, clips beside the draft, a clip or a figure in a margin slot, figures as files
  • rust-shared efcda42 star-web-edit: contain() + typed EditError + expect on text ops; blocks: unwrap the studio's mapped <p>
  • rust-shared 6a6d386 style: rustfmt blocks.rs, sidenotes.rs (format only, before the StarLoom QoL pass)

  • rust-shared 25461b8 star-web viewer: the first view opens on the lead card's row at the cards' own size (DS2 of the depth plan)
  • rust-shared 93272fa star-web: one token source held to the generated CSS; the house wordmark in the shell; focus rings, control borders, targets, the cloze as a disclosure, a skip link, inert full screen
  • rust-shared f18603c star-web board: a world's clip previews under the pointer behind a play mark; grouped cards read together; the e2e walks s2ar.dev's front board

The work record as of , from the fold on tower.

Nothing open against these sources.

  • FAILlint/web-reference 12 Nov on tower
  • PASSnode/board-stepper 6 Nov on tower

Generated by tools/reference_pages.py from star-web/src/board_rt/viewer.js, star-web/src/board_rt/stepper.js, star-web/src/board_rt/edit.js, star-web/src/board_rt/history.js, star-web/src/board_rt/bench.js, star-web/src/board_rt/flow.js, star-web/src/board_rt/graph.js, star-web/src/board_rt/splice.js, star-web/src/blocks.rs, star-web/src/board.rs, star-web/tests/board_rt/examples.json; the twin bfaad079a7ce (434093 bytes). The words are a draft.