@readymadeit/mcp 0.0.0-stage → 0.1.0

package/bundle/docs/content/boards/nested-rhythm-demo-board.md

@@ -0,0 +1,165 @@
+# Nested Rhythm
+
+A drum groove with no sequencer, no step grid and no wiring: every hit is timed
+by where it sits in a nest of sub-services. Four patterns to choose from, each
+built from the same kind of blocks. The tempo and the pattern are set in one
+place, and every level of the nest reads them from there.
+
+## What it does
+
+Press **Play** and it loops a one-bar groove until you press **Stop**. Pick a
+pattern and it takes over at the next bar line. Turn **Tempo** and the whole
+groove follows. The playground shows the playhead: each
+service lights up while it runs, and a waiting Timer stays lit for as long as
+it waits, so you can watch the bar move down through the levels.
+
+## How it works
+
+One [browser runtime](../concepts/runtime.md) holding one
+[scope](../concepts/scopes.md), the **Groove**. Every bar starts with the clock
+ticking; **Which pattern** reads the chosen pattern's name out of a slot, and a
+[Switch](../services/switch.md) routes the bar into the pattern of that name.
+Each pattern is a [Browser Sub-Service](../services/browser-sub-service.md)
+holding four more, one per beat, and each beat holds the **Notes** that fall
+in it:
+
+```
+Groove                     (scope: own slots)
+├─ Tempo                   (Hold → slot "tempo", 120)
+├─ Pattern                 (Hold → slot "pattern", "straight")
+├─ One bar                 (Timer, every 4 beats)
+├─ Which pattern           (Hold ← slot "pattern")
+└─ Patterns                (Switch)
+   ├─ Straight             (inherits slots)
+   │  ├─ Beat 1             (inherits slots)
+   │  │  ├─ Kick            Note: 0 · kick · 0
+   │  │  ├─ Hi-hat          Note: 0 · hi-hat · ½
+   │  │  │  ├─ Wait before  (Timer, 0 beats)
+   │  │  │  ├─ Sound        (Sound: hi-hat)
+   │  │  │  └─ Wait after   (Timer, ½ beat)
+   │  │  └─ Hi-hat          Note: 0 · quieter hi-hat · ½
+   │  ├─ Beat 2
+   │  │  ├─ Snare           Note: 0 · snare · 0
+   │  │  └─ …
+   │  ├─ Beat 3
+   │  └─ Beat 4
+   ├─ Shuffle
+   ├─ Four on the floor
+   └─ Funk
+```
+
+The Note is the board's one [block](../concepts/blocks.md): defined once, used
+for every drum hit, with four parameters given at each use —
+
+| Parameter | What it is |
+|---|---|
+| `waitBefore` | beats to wait before the sound |
+| `sound` | which drum: `kick`, `snare`, `hihat` |
+| `waitAfter` | beats to wait after it |
+| `volume` | 0 to 1 |
+
+A Timer that is not periodic holds whatever it is given for its delay, then
+passes it on, and one of zero passes it on at once. A sub-service answers once
+its pipeline has, so **a Note lasts as long as its two waits**, a beat as
+long as its Notes, and a bar as long as its four beats. A Note with nothing after it sounds together with the next
+one: the kick and the first hi-hat land on the same instant because the kick
+waits for nothing.
+
+Each Note carries its own stretch of time, so it can be read, moved or changed
+without working out what its neighbours do. That is the reason for two waits
+where one would do: a wait before the sound could always be written as a wait
+after the note before it, but then shaping one note would mean editing
+another.
+
+## The patterns
+
+Every pattern is four beats of Notes. What makes them different is only which
+drums are in them and how their waits are split:
+
+| Pattern | Kick | Snare | Hi-hat |
+|---|---|---|---|
+| **Straight** | 1 | 2, 4 | every eighth |
+| **Shuffle** | 1, 3 | 2, 4 | every eighth, swung |
+| **Four on the floor** | every beat | 2, 4 | the off-beats |
+| **Funk** | 1, the "and" of 2, the "and" of 3 | 2, 4 | every sixteenth |
+
+Straight and Shuffle show what the wait before is for. A straight hi-hat is
+`0 · hi-hat · ½`: it plays, then takes half a beat. The Shuffle's second
+hi-hat of each beat is `⅙ · hi-hat · ⅓`: it still takes half a beat, but plays
+a sixth of a beat into it, which lands it two thirds of the way through the
+beat. The swing lives in that one note; the Note before it is a plain eighth.
+
+The Funk's pushed kicks are the same idea without a wait: a `0 · kick · 0` Note
+just before the third sixteenth of a beat sounds with that hi-hat, on the
+"and".
+
+A pattern is chosen once per bar, when Which pattern reads the slot, so a new
+choice never cuts into the bar that is playing.
+
+## Where the tempo lives
+
+No Timer on the board knows how long anything takes. Each one waits a number
+of [**beats**](../services/timer.md#beats), and looks the tempo up in a
+[slot](../services/hold.md#where-its-cells-live) called `tempo` each time it
+waits.
+
+The slot belongs to the Groove, which keeps its cells to itself
+(`scope: { slots: "own" }`); the **Tempo** Hold writes the board's tempo into
+it. Every scope inside says `scope: { slots: "inherit" }`, meaning *my cells
+are the ones of whatever holds me*. So a Note asks its beat, which asks the
+pattern's bar, which asks the Groove. The Switch between them is not a scope
+and passes the question straight through: a case is a branch of the pipeline
+around it. The Note is written without knowing where the tempo is set, or that
+it is set at all.
+
+That default matters: a scope keeps its cells to itself unless it says
+otherwise, so a reusable block cannot pick up a slot by accident. Here each
+level opts in, and the board says so.
+
+The Tempo knob configures the Hold, which writes the slot. The next wait
+anywhere in the nest reads the new tempo, and the clock applies it from the
+bar after the one already scheduled. The pattern buttons do the same with the
+Pattern Hold. The board saves the tempo and pattern last set, so the groove
+comes back as it was left.
+
+## Why one block
+
+An earlier version of this board built each pattern from blocks for a beat,
+two beats, a swung beat and so on, each defined once and used wherever it
+recurred. It wrote less down, but the blocks were whatever happened to repeat
+across the four patterns: add a fifth pattern and the best grouping changes.
+A musician changing a pattern thinks in notes, not in which repeats a block
+happens to capture. One Note block with four parameters fits any pattern, and
+a new pattern is four new beats of Notes.
+
+The beats are plain sub-services, not blocks: they are there to give a bar the
+shape a musician reads it in, not to be reused. Each one is exactly a beat
+long, so a beat can be opened, read and changed on its own, and its Notes'
+waits add up to one.
+
+## Timing
+
+The clock starts every bar, so the drums never drift apart over time. Within
+a bar each wait runs a couple of milliseconds late in the browser, and those
+add up to around 20 ms by the last eighth before the next tick starts the bar
+fresh. Turning the tempo mid-bar gives one uneven bar: the waits still ahead
+play at the new tempo, but the next tick was already scheduled at the old one.
+
+**Stop** does two things: it stops the clock, and it
+[cancels](../services/browser-sub-service.md#commands) the Groove. Cancelling
+ends the bar already playing where it is, so the groove stops at once rather
+than at the end of the bar.
+
+A drum is heard after the latency of the audio output, which the Sound panels
+show. On wired speakers it is a few milliseconds; a Bluetooth device can add a
+couple of hundred, and then the playhead in the playground runs visibly ahead
+of what you hear.
+
+## Try it
+
+Press **Play**, then switch between the patterns and turn **Tempo**. Open the
+Shuffle in the playground and set the `waitBefore` of a swung hi-hat to 0.25
+with a `waitAfter` of 0.25 for a harder swing on that one eighth — the others
+keep theirs. Or add a Note: a `0 · snare · 0` at volume 0.2, placed just
+before the second hi-hat of Straight's Beat 2, sounds with it — a ghost snare on the
+"and" of 2, and nothing else in the bar moves.

package/bundle/docs/content/boards/next-bus-board.md

@@ -0,0 +1,38 @@
+# Next Bus
+
+Asks Berlin's public transport API when the next bus leaves and answers with a
+sentence somebody could say out loud. A skill target: built to be called by the
+voice assistant, not opened on its own.
+
+## What it does
+
+It returns `{ "text": "The next bus leaves in 7 minutes." }`, or a fallback
+sentence when nothing is departing in the window it asked about.
+
+## How it works
+
+One [browser runtime](../concepts/runtime.md), four services, no state.
+
+1. **Fetch Departures**, a [Fetcher](../services/fetcher.md), GETs from
+   `v6.bvg.transport.rest` for one stop and one direction, ten minutes ahead.
+2. **Pick Departure**, a [Map](../services/map.md) in `replace` mode, takes the
+   first departure's `when` timestamp.
+3. **Build Sentence**, another [Map](../services/map.md), turns the difference
+   between then and now into minutes and wraps it in a sentence.
+4. **Sentence**, a [Monitor](../services/monitor.md), reports the answer.
+
+Which stop it watches is the Fetcher's `url` and nothing else — change the
+`stops/…` and `direction` ids there to point it somewhere else.
+
+## Why it is a board
+
+The Voice Assistant with skills board
+(`boards/voice-assistant-skills-demo-board.json`) dispatches to this one by name
+through
+[Skill Router](../services/skill-router.md), and reads the returned `text` aloud
+with [text-to-speech](../services/text-to-speech.md). Save it locally as
+`next bus` or the dispatcher will not find it.
+
+[Next Bus Switch](./next-bus-switch-board.md) is the same board with the
+sentence-building moved into a [Switch](../services/switch.md); it is worth
+reading the two together.

package/bundle/docs/content/boards/next-bus-switch-board.md

@@ -0,0 +1,44 @@
+# Next Bus Switch
+
+The same job as [Next Bus](./next-bus-board.md) — when does the next bus leave —
+built so that the "or else" is a branch in the board rather than a conditional
+hidden inside a template string.
+
+## What it does
+
+Identical output: a speakable sentence about the next departure, or a sentence
+saying there is not one.
+
+## How it works
+
+One [browser runtime](../concepts/runtime.md).
+
+1. **Fetch Departures**, a [Fetcher](../services/fetcher.md), asks
+   `v6.bvg.transport.rest` for the next ten minutes at one stop.
+2. **Pick Departure**, a [Map](../services/map.md), takes the first upcoming one.
+3. **Branch Sentence**, a [Switch](../services/switch.md), is the difference.
+   Its matched case runs a [Map](../services/map.md) building
+   *"The bus leaves in N minutes at HH:mm."*; its `default` case runs a
+   different Map answering *"I found no upcoming departures."*
+4. **Sentence**, a [Monitor](../services/monitor.md).
+
+## Why this version exists
+
+In [Next Bus](./next-bus-board.md) the missing-departure case is handled inside
+the template that builds the sentence — a conditional expressed as an
+expression. It works, and it is the shorter board.
+
+This version makes the two outcomes two visible paths. You can see at a glance
+that there are exactly two answers, and each one is a plain template with no
+branching in it. That is the trade the
+[structured-flow principle](../concepts/runtime.md#control-flow) is about:
+a conditional inside a string is invisible, a Switch is a thing you can point
+at.
+
+Both are correct. Which one is better depends on whether the board is something
+you will come back to.
+
+## Try it
+
+Save it as `next bus switch` and point the skill router's *next bus departure*
+skill at it to use this version instead.

package/bundle/docs/content/boards/night-groove-demo-board.md

@@ -0,0 +1,110 @@
+# Night Groove
+
+The [Timeline demo](./timeline-demo-board.md)'s night sky with a drum groove
+under it. One timeline plays both: it counts in beats, and its placements say
+when each drum and each image comes in. Four bars long and looping, with a
+tempo knob that speeds up the band and the sky together.
+
+## What it does
+
+Press **Play**. The hi-hats start on the first beat, and a star pops in on each
+beat of the first bar. On the second bar the kick comes in, four to the bar,
+and a rocket launches with it; a moon appears in the corner and beats with
+every kick. On the third bar the snare lands on the backbeat and the planet
+arrives. The last two beats are a snare fill, and a comet crosses the sky
+while it plays. Then it all starts over.
+
+**Pause** holds the picture and silences the band at once; **Play** carries on
+from there. **Stop** goes back to the start. Turning **Tempo** changes how long
+a beat lasts, from the next frame on, for the drums and the pictures alike.
+
+## How it works
+
+One [browser runtime](../concepts/runtime.md) with five services:
+
+```
+Tempo                      (Hold, writes 120 into the slot "tempo")
+Show                       (Timeline, own clock in beats: 16, looping, 60 fps)
+Band                       (Tracks, one track per drum; passes the frame on)
+├─ hats                    Drum · hihat on 0 and ½ of every beat
+├─ kick                    Drum · kick on every beat
+├─ snare                   Drum · snare on the second of every two beats
+└─ fill                    Drum · six snares over two beats
+Scene                      (Tracks, one track per picture, run in order)
+├─ sky                     Timeline, reads the Show's time
+├─ moon                    Timeline, takes the name "kick"
+├─ planet                  Pop
+├─ star-1 … star-4         Pop
+├─ rocket                  Fly
+└─ comet                   Fly
+Canvas                     (draws the Scene's answer)
+```
+
+The **Show** keeps the clock, sixty times a second. It counts in
+[beats](../services/timeline.md#where-time-comes-from), and a beat is as long
+as the tempo held in the slot `tempo` says. **Tempo** is a
+[Hold](../services/hold.md) that writes 120 there when the board loads, and
+the knob writes a new value into it.
+
+Every frame goes to the **Band** first. It is a [Tracks](../services/tracks.md)
+service whose tracks only make a sound; its reducer answers with the frame it
+was given, so the **Scene** behind it receives the Show's frame, not the Band's
+answers. The Scene then draws as the Timeline demo does.
+
+## The Drum block
+
+The drums are written once, as a [block](../concepts/blocks.md) of three
+services:
+
+| Service | What it does |
+|---|---|
+| **Loop** | A timeline driven by the Show, a few beats long and looping, with an [action](../services/timeline.md) at each hit |
+| **On a hit** | A [Filter](../services/filter.md) that lets a frame through only when an action fell in it |
+| **Sound** | A [Sound](../services/sound.md) in drums mode that plays its drum for every frame it is given |
+
+A use says which drum, how loud, how long its loop is and where the hits lie:
+
+| Use | Drum | Loop | Hits at | Volume |
+|---|---|---|---|---|
+| `hats` | hihat | 1 beat | 0, 0.5 | 0.35 |
+| `kick` | kick | 1 beat | 0 | 0.9 |
+| `snare` | snare | 2 beats | 1 | 0.7 |
+| `fill` | snare | 2 beats | 0, 0.5, 1, 1.25, 1.5, 1.75 | 0.5 |
+
+Nothing is scheduled. A hit is an action on a timeline, and the timeline works
+out from each frame's time which actions it passed. That is why Pause silences
+the band: no frame, no hit. It also means a hit sounds with the first frame
+after its moment, up to a sixtieth of a second late.
+
+## Placements
+
+The Show's [placements](../services/timeline.md#placements) arrange sound and
+picture the same way, by name, in beats:
+
+| Beat | For | Sound | Picture |
+|---|---|---|---|
+| 0 | 16 | `hats` | |
+| 0, 1, 2, 3 | 4 each | | `star-1` … `star-4` |
+| 4 | 12 | `kick` | the moon, which takes `kick` too |
+| 4 | 8 | | `rocket` |
+| 8 | 6 | `snare` | `planet` |
+| 12 | 2 | | `star-1`, again |
+| 14 | 2 | `fill` | `comet` |
+
+A drum's loop **repeats** for as long as its placement lasts: the kick's one-beat
+loop plays twelve times. A picture that does not loop is **stretched** to its
+placement, as in the Timeline demo: Pop is three beats of its own, played over
+four.
+
+The moon shows that a name can be taken twice. The Show places `kick` once;
+the kick's drum and the moon's timeline both take it. The moon loops one beat,
+its radius jumping to 10 % on the beat and easing back to 7 %, so it is on
+screen exactly while the kick plays and swells on every kick.
+
+## Try it
+
+Open the Show's timeline and drag the `snare` placement to start on beat 4:
+the backbeat and the planet still arrive separately, because the planet has
+its own placement. Set the moon's `placement` to `snare` and it rises with the
+snare instead, on the third bar. Turn the tempo right down and watch the
+stars pop in slow motion, one per beat.

package/bundle/docs/content/boards/noise-alert-board.md

@@ -0,0 +1,44 @@
+# Noise Alert
+
+Watches the microphone level and sends a push notification when a room gets too
+loud. Four services, one of which exists purely to stop it firing forty times a
+second.
+
+## What it does
+
+It measures sound level continuously, and when the level crosses a threshold you
+set, posts a message to an [ntfy.sh](https://ntfy.sh) topic — which arrives on
+your phone.
+
+## How it works
+
+One [browser runtime](../concepts/runtime.md). Audio never leaves the page; only
+the alert does.
+
+1. [Microphone Monitor](../services/microphone-monitor.md) samples the input
+   level every 50 ms. It starts stopped, because a board that grabs the
+   microphone the moment it loads would be rude.
+2. [Filter](../services/filter.md) is the threshold. Below it, the filter stops
+   propagation and the rest of the chain never runs — which is the ordinary way
+   to express "only when" without a branch.
+3. [Debounce](../services/debounce.md) holds a three-second cooldown. Without it
+   a single loud noise would send twenty notifications, because the level stays
+   over the line for as long as the noise lasts.
+4. [Fetcher](../services/fetcher.md) POSTs to the ntfy topic. Its body is an
+   expression, not a fixed string —
+   `concat('Noise threshold exceeded! Level: ', string(round(params.levelDb, 1)), ' dB')` —
+   so the measured level travels with the alert.
+
+Steps 2 and 3 are the whole design. The measurement is trivial; making it fire
+*once per event* rather than once per sample is the part that takes thought, and
+it is two services rather than any code.
+
+## The facade
+
+A level meter shows the live reading, a knob sets the threshold, two buttons
+start and stop the monitor, and a text input holds the ntfy topic.
+
+## Try it
+
+Replace `YOUR_TOPIC_NAME` in the Fetcher URL with a topic of your own, subscribe
+to it in the ntfy app, then start the monitor and make a noise.

package/bundle/docs/content/boards/pad-groove-demo-board.md

@@ -0,0 +1,93 @@
+# Pad Groove
+
+A four-chord song with no picture: a soft pad, a bass line and the drums from
+[Night Groove](./night-groove-demo-board.md), arranged on one
+[timeline](../services/timeline.md) that counts in beats. Eight bars long and
+looping, with a tempo knob.
+
+## What it does
+
+Press **Play**. For two bars the pad plays alone: A minor 7, F major 7,
+C major and G major, a chord a bar, each swelling in and fading into the
+next. The hi-hats join on the third bar. On the fifth the bass and the kick
+come in together, and on the seventh the snare lands on the backbeat. The last
+two beats are a snare fill, and the song starts over with the pad.
+
+**Pause** stops anything new from playing and **Play** carries on from there;
+**Stop** goes back to the start. A chord already sounding plays out its bar and
+its release either way. **Tempo** changes how long a beat lasts, from the next
+frame on, and the chords are held for their bar at the new tempo.
+
+## How it works
+
+One [browser runtime](../concepts/runtime.md) with three services:
+
+```
+Tempo                      (Hold, writes 96 into the slot "tempo")
+Song                       (Timeline, own clock in beats: 32, looping, 60 fps)
+Band                       (Tracks, one track per part)
+├─ pad                     Notes · soft wave, a chord a bar
+├─ bass                    Notes · triangle wave, four notes a bar
+├─ hats                    Drum  · hihat on 0 and ½ of every beat
+├─ kick                    Drum  · kick on 0 and 2½ of every bar
+├─ snare                   Drum  · snare on the second of every two beats
+└─ fill                    Drum  · six snares over two beats
+```
+
+The **Song** keeps the clock and counts in beats of the tempo held in the slot
+`tempo`. Every frame carries that tempo along with the time, and the **Band**
+gives each frame to every part. A part that is not placed answers null at once
+and plays nothing.
+
+## Two blocks
+
+Every part is a use of one of two [blocks](../concepts/blocks.md). **Drum** is
+Night Groove's: a loop of hits and a [Sound](../services/sound.md) that plays
+one drum. **Notes** is its melodic counterpart:
+
+| Service | What it does |
+|---|---|
+| **Loop** | A timeline driven by the Song, a few beats long and looping, with an action for every note: `{ "at": 4, "data": { "note": "F3" } }` |
+| **On a note** | A [Filter](../services/filter.md) that lets a frame through only when a note fell in it |
+| **Notes and tempo** | A [Map](../services/map.md) that keeps the notes due and the frame's tempo: `{ "notes": [...], "tempo": 96 }` |
+| **Synth** | A Sound in synth mode that plays every note it is given at once |
+
+A chord is several actions at the same moment: a timeline fires every action
+due in a frame, in list order, so the four notes of a chord reach the synth
+together.
+
+| Use | Wave | Loop | Attack | Held for | Release | Volume |
+|---|---|---|---|---|---|---|
+| `pad` | soft | 16 beats | 0.8 s | 4 beats | 1.6 s | 0.09 per note |
+| `bass` | triangle | 16 beats | 0.01 s | 0.4 beats | 0.12 s | 0.45 |
+
+Note lengths are in **beats**, which is why the tempo travels in the frame.
+A service inside a [Tracks](../services/tracks.md) track sees only the slots
+of its track, not the `tempo` slot the Song reads. So the Song puts the tempo
+it counted at on every frame, the Map hands it to the synth with the notes,
+and the synth holds each note for its beats at that tempo. The pad's release
+starts after its bar, so each chord fades out while the next one swells in.
+
+## Placements
+
+| Beat | For | Part |
+|---|---|---|
+| 0 | 32 | `pad` |
+| 8 | 24 | `hats` |
+| 16 | 16 | `bass`, `kick` |
+| 24 | 6 | `snare` |
+| 30 | 2 | `fill` |
+
+A looping part **repeats** for as long as its placement lasts, from the moment
+it is placed. The pad and the bass each loop four bars. The bass comes in on
+beat 16, where the pad's loop starts over, so the first note of the bass is
+under the first chord of the pad. Placed on beat 8 instead, the bass would
+play A under the C major chord.
+
+## Try it
+
+Open the pad's use and give it a `wave` of `organ`, or a `release` of 3 for a
+wash of overlapping chords. Drag the `bass` placement in the Song's timeline to
+beat 8 and hear it come in on the wrong chord, then to beat 0, where both loops
+start together again. Turn the tempo down to 60: the chords stretch with the
+bars.

package/bundle/docs/content/boards/peer-chat-board.md

@@ -0,0 +1,49 @@
+# Peer Chat
+
+Two people, two browsers, no server in between. Four services and a public
+signalling host are enough for a working chat.
+
+## What it does
+
+Type a message; it appears in the other person's window. Both sides run the same
+board, each naming itself and the other.
+
+## How it works
+
+One [browser runtime](../concepts/runtime.md).
+
+1. **Message**, an [Injector](../services/injector.md) in plain-text mode, is
+   the composer.
+2. [Peer Socket](../services/peer-socket.md) in *Receive and Send* does the
+   rest. It registers under a `peerName`, dials `targetPeer`, and pushes
+   anything that arrives downstream on its own — independently of anything you
+   type.
+3. **Incoming Messages**, a [Monitor](../services/monitor.md), keeps the thread.
+4. [Stopper](../services/stopper.md) ends the chain.
+
+## Why the stopper is there
+
+Peer Socket both sends what it receives from upstream and injects what arrives
+from the network. Without a stopper the injected message would continue past the
+monitor and, in a longer board, be treated as a fresh trigger. Ending the chain
+explicitly says *this value has arrived, not departed*.
+
+## Signalling, and what "no server" means
+
+WebRTC still needs a rendezvous to introduce two browsers — here
+`peerjs.hookitapp.com`. Once the connection is up, messages go directly between
+the two peers and the signalling host sees none of them.
+
+If you would rather not depend on a public host,
+[Peer Chat over Node](./peer-chat-node-board.md) is the same board with the
+signalling server moved onto a runtime of your own.
+
+## The facade
+
+Two lines of text showing the local and remote peer names, a button, and a
+[message list](../concepts/board.md#the-facade) with a composer.
+
+## Try it
+
+Open it in two browsers. Swap `peerName` and `targetPeer` between them so each
+names itself and the other.

package/bundle/docs/content/boards/peer-chat-node-board.md

@@ -0,0 +1,47 @@
+# Peer Chat over Node
+
+The same chat as [Peer Chat](./peer-chat-board.md), with the signalling server
+moved out of somebody else's cloud and onto a runtime you run. A good, small
+example of a [mount](../concepts/mounts.md).
+
+## What it does
+
+Identical behaviour: messages typed in one browser appear in another. What
+changes is who introduces the two peers.
+
+## How it works
+
+Two runtimes.
+
+### Browser
+
+1. **Message**, an [Injector](../services/injector.md).
+2. [Peer Socket](../services/peer-socket.md) in *Receive and Send*. Instead of
+   naming a public host it carries
+   `hkp-mount://chat-node/chat-peer-server-svc` — a reference to the service on
+   the other runtime, resolved to a real address when the board loads.
+3. **Incoming Messages**, a [Monitor](../services/monitor.md).
+4. [Stopper](../services/stopper.md).
+
+### Node
+
+1. **Peer Server** hosts the signalling endpoint. It binds no port of its own:
+   its runtime gives it a path on the server it already has, and publishes the
+   address as `__hkpMount`.
+2. **Peer Events**, a [Monitor](../services/monitor.md), shows peers arriving
+   and leaving, because `emitEvents` is on.
+
+## Why this is the interesting version
+
+The peer-to-peer part is unchanged — messages still travel directly between
+browsers. What moved is the one piece that could not be peer-to-peer, and moving
+it took no code: a service that hosts an endpoint, and a reference to that
+service where an address would otherwise be.
+
+Because the address is [derived rather than drawn](../concepts/mounts.md), it
+survives restarts. A board saved today still points at the right place tomorrow.
+
+## Try it
+
+It needs an hkp-node kept under the name `node` in *Manage runtime servers*.
+Open the board in two browsers, both keeping the same server under that name.