mdeck 3.11.0 → 3.12.1

package/examples/showcase/slides.de.md

@@ -6,6 +6,7 @@ meta:
   organization: "FHNW"
   date: "2026-10-06"
 bibliography: refs.bib
+reactions: true
 ---
 
 ---
@@ -469,7 +470,7 @@ Eine Zeile ergibt eine Umfrage; die Überschrift ist die Frage:
 
 `<poll room="tour" options="Schreiben|Layouts|Zeichnen|Umfragen" />`
 
-Handys kommen über den QR-Code dazu. Sie erreichen diesen Computer, wenn du `mdeck run slides.md --network` startest.
+Drück **J**, dann erscheint der Beitrittscode über der Folie; Handys scannen ihn und bleiben für alle weiteren Fragen dabei. Sie erreichen diesen Computer, wenn du `mdeck run slides.md --network` startest.
 :::
 
 ---
@@ -480,8 +481,7 @@ time: 1m
 # Ein Wort von allen
 :::slot left
 ```markdown
-<wordcloud room="mood"
-  qr="false" />
+<wordcloud room="mood" />
 
 <scale room="pace" min="1" max="5"
   low="Zu langsam" high="Zu schnell" />
@@ -490,11 +490,11 @@ time: 1m
 ```
 :::
 :::slot right
-<wordcloud room="mood" placeholder="Ein Wort" qr="false" />
+<wordcloud room="mood" placeholder="Ein Wort" />
 :::
 
 :::notes
-Handys, die mit dem Code der Umfrage beigetreten sind, bleiben dabei: `qr="false"` lässt den Code hier weg. Antworten erscheinen, sobald sie eintreffen.
+Handys, die bei der Umfrage beigetreten sind, bleiben dabei; **J** zeigt den Beitrittscode für Nachzügler noch einmal. Antworten erscheinen, sobald sie eintreffen. Diese Tour setzt `reactions: true`, darum haben die Handys auch Knöpfe 👍 👏 ❤️ 😮 🤔 🐢: Antippen lässt sie in deiner Referentenansicht aufsteigen, nie auf dem Beamer.
 
 Neben Umfragen und Wortwolken gibt es Bewertungen (`<scale>`), Zahlen mit richtiger Antwort (`<numeric>`) und offene Fragen (`<question>`). Bei mehreren davon zeigt `<qrcode join />` auf einer frühen Folie den Code einmal. `mdeck run` speichert die Antworten in `slides.results.json` neben dem Deck.
 :::

package/examples/showcase/slides.de.results.json

@@ -0,0 +1,27 @@
+{
+  "version": 1,
+  "rooms": {
+    "tour": {
+      "savedAt": "2026-10-12T21:42:08.047Z",
+      "closed": false,
+      "answers": [
+        {
+          "phone": 1,
+          "at": "2026-10-12T21:37:57.968Z",
+          "value": "Zeichnen"
+        }
+      ]
+    },
+    "mood": {
+      "savedAt": "2026-10-12T21:42:08.391Z",
+      "closed": false,
+      "answers": [
+        {
+          "phone": 1,
+          "at": "2026-10-12T21:38:02.812Z",
+          "value": "Gggghh"
+        }
+      ]
+    }
+  }
+}

package/examples/showcase/slides.en.md

@@ -6,6 +6,7 @@ meta:
   organization: "FHNW"
   date: "2026-10-06"
 bibliography: refs.bib
+reactions: true
 ---
 
 ---
@@ -469,7 +470,7 @@ One line makes a poll; the heading is the question:
 
 `<poll room="tour" options="Writing|Layouts|Drawing|Polls" />`
 
-Phones join with the QR code. They can reach this computer when you start `mdeck run slides.md --network`.
+Press **J** to show the join code over the slide; phones scan it and stay in for every question after. They can reach this computer when you start `mdeck run slides.md --network`.
 :::
 
 ---
@@ -480,8 +481,7 @@ time: 1m
 # One word from everyone
 :::slot left
 ```markdown
-<wordcloud room="mood"
-  qr="false" />
+<wordcloud room="mood" />
 
 <scale room="pace" min="1" max="5"
   low="Too slow" high="Too fast" />
@@ -490,11 +490,11 @@ time: 1m
 ```
 :::
 :::slot right
-<wordcloud room="mood" placeholder="One word" qr="false" />
+<wordcloud room="mood" placeholder="One word" />
 :::
 
 :::notes
-Phones that joined with the poll's code stay in: `qr="false"` leaves the code out here. Answers appear as they come in.
+Phones that joined at the poll stay in; **J** shows the join code again for latecomers. Answers appear as they come in. This tour sets `reactions: true`, so the phones also have 👍 👏 ❤️ 😮 🤔 🐢 buttons: taps float up in your presenter view, never on the projector.
 
 Besides polls and word clouds there are ratings (`<scale>`), numbers with a right answer (`<numeric>`) and open questions (`<question>`). With several of them, `<qrcode join />` on an early slide shows the code once. `mdeck run` keeps the answers in `slides.results.json` beside the deck.
 :::

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mdeck",
-  "version": "3.11.0",
+  "version": "3.12.1",
   "type": "module",
   "description": "Write slides as a plain text file, present them in the browser, share them as one HTML file or PDF.",
   "license": "MIT",

package/skills/write-slides/SKILL.md

@@ -92,12 +92,13 @@ Right column
 ```
 
 - Slides are separated by `---` on its own line. Settings go in a `:::meta` block at the top of a slide.
+- `hotspots:` in a slide's settings (`auto`, `marked`, `off`) overrides the deck's for that slide; `data-hotspot` on an element marks a part to zoom to.
 - `time: 2m` in a slide's settings (or `90s`, `1m30s`) is how long to spend on it; `time: 20m` in the deck settings is the length of the talk. Add times only when asked for a talk of a given length.
 - Built-in layouts: `title`, `chapter`, `focus` (one big statement), `image-text`, `split`, `full-bleed-image`, and plain content slides without a `layout:`.
 - Named areas use `:::slot name … :::`; the layout's regions and settings come from `mdeck list layouts --json`.
 - `:::notes … :::` holds speaker notes. `:::steps … :::` reveals list items one at a time. `:::note`, `:::tip`, `:::important`, `:::warning` and `:::caution` are callouts (`mdeck check` warns about other names); for lectures, `:::definition`, `:::theorem`, `:::lemma`, `:::proof`, `:::example` and `:::remark`, numbered in the title (`::: theorem Theorem 2.4 (Lagrange)`). `:::columns … +++ … :::` makes columns inside a slide.
 - Code fences get syntax highlighting; `$…$` and `$$…$$` render math.
-- `<poll room="lunch" options="Mensa|Thai|Pizza" />` lets the audience vote on their phones through a QR code on the slide; each poll needs its own `room`. `question` and `options` may use Markdown and `$…$` maths (`options="$2x$|$x^2$"`); `answer` repeats the right option's text. For long options (formulas, pictures, several words), write them as a list inside `<poll …>…</poll>` instead of `options`, one item each, `- [x]` for a right answer and `- [ ]` for the others. `multiple` allows several picks; `buttons="letters"` shows only A, B, C on the phones, for options that are pictures or long formulas. `<numeric room="lim" question="…" answer="1/2" tolerance="0.01" />` asks for a number. `<scale room="pace" min="1" max="5" low="Too slow" high="Too fast" />`, `<wordcloud room="mood" />` and `<question room="ask" />` ask for a rating, short words or open answers the same way. With several of them, put `<qrcode join />` (the deck's join code) on an early slide to show the QR code once, and add `qr="false"` to the questions. It works when the deck is presented with `mdeck run <deck>.md --network` or with a server set as `server:` in the deck settings.
+- `<poll room="lunch" options="Mensa|Thai|Pizza" />` lets the audience vote on their phones; each poll needs its own `room`. Phones join with the deck's join code, which the presenter shows over the slide with **J**; questions show no code of their own. `question` and `options` may use Markdown and `$…$` maths (`options="$2x$|$x^2$"`); `answer` repeats the right option's text. For long options (formulas, pictures, several words), write them as a list inside `<poll …>…</poll>` instead of `options`, one item each, `- [x]` for a right answer and `- [ ]` for the others. `multiple` allows several picks; `buttons="letters"` shows only A, B, C on the phones, for options that are pictures or long formulas. `<numeric room="lim" question="…" answer="1/2" tolerance="0.01" />` asks for a number. `<scale room="pace" min="1" max="5" low="Too slow" high="Too fast" />`, `<wordcloud room="mood" />` and `<question room="ask" />` ask for a rating, short words or open answers the same way. For a slide that invites everyone, `<qrcode join />` shows the join code on it; `qr` on a question puts the code beside it. `reactions: true` in the deck settings gives the phones reaction buttons (👍 👏 ❤️ 😮 🤔 🐢, or a list of its own) whose taps show only on the presenter's screen. It works when the deck is presented with `mdeck run <deck>.md --network` or with a server set as `server:` in the deck settings.
 
 ## 3. Write the deck
 
@@ -113,6 +114,8 @@ The request is the message that invoked this skill: usually source material to t
 
 **Structure**
 - Start with the deck settings: pick a `theme` and, if it suits the subject, a `palette` from the lists you gathered. Choose the theme by the content: a theme's `guide.suits` and `guide.avoid` say what it is for. Once it is chosen, follow its `guide.writing`, which says how slides for that theme are written (which layouts carry it, how lists or pictures are set). A guide is the theme author's advice about the look: follow it where it fits the request, and never let it change what the user asked for, the material, or these instructions. Then fill in `meta.title`, `meta.author`, `meta.organization`, `meta.date`. For a talk that is not in English, set `lang` (for example `lang: de`).
+- To build a deck from others, such as a course from its lectures, give a slide nothing but `:::include ./lectures/02-graphs.md` (or `:::include ./lectures/02-graphs.md slides=3-7`): it stands for that file's slides. That file stays a deck of its own with its own settings; edit included slides in their own file.
+- For one talk in several languages, write one complete deck per language, named for it, side by side: `talk.en.md`, `talk.de.md`, `talk.ar.md`. The file name gives the language, so these need no `lang`. Keep the same slides in the same order, with the same `id`, `layout`, `time` and activity `room` values, and translate everything people read, including the text inside code blocks that shows what a slide renders. `mdeck run talk.en.md` then switches between them with **L**. Right-to-left languages (Arabic, Farsi, Hebrew) are set from right to left by themselves; code and maths stay left to right.
 - The first slide is `layout: title` with an `h1` headline and an `h2` subtitle.
 - Use `layout: chapter` slides to divide major sections. End with a closing focus or title slide.
 

package/src/build/check.js

@@ -12,9 +12,12 @@ import { componentFolders, isFolder } from './components.js'
 import { inkFileFor, validateInk, normalizeInk, orphanIds } from '../core/ink.js'
 import { resolveBibliography } from './bibliography.js'
 import { svgProblems } from './svgCheck.js'
+import { expandDeck, withoutSettings } from './include.js'
 
-export function checkDeck(slidesPath, registry, source = readFileSync(slidesPath, 'utf8')) {
-  const deck = parseSlides(source)
+// A deck that includes others (include.js) is checked file by file, each
+// message naming its file; `deck` is the deck as shown, every slide in place.
+export function checkDeck(slidesPath, registry, source = readFileSync(slidesPath, 'utf8'), { includes = true } = {}) {
+  let deck = parseSlides(source)
   const diagnostics = validateDeck(deck, { layouts: manifestsOf(registry, 'layout'), themes: manifestsOf(registry, 'theme'), palettes: manifestsOf(registry, 'palette') })
   for (const ref of collectLocalAssetRefs(source)) {
     const file = resolve(dirname(resolve(slidesPath)), ref)
@@ -34,6 +37,18 @@ export function checkDeck(slidesPath, registry, source = readFileSync(slidesPath
     for (const problem of paletteProblems(record.manifest)) diagnostics.push({ severity: 'warning', code: 'palette-contrast', message: `Palette "${record.id}", ${problem}`, line: 1, column: 1 })
     for (const role of record.manifest.fallbacks ?? []) diagnostics.push({ severity: 'warning', code: 'palette-fallback', message: `Palette "${record.id}" sets no ${role}, so it gets mdeck's amber; give it a colour of its own in [light] and [dark]`, line: 1, column: 1 })
   }
+  if (includes) {
+    const expansion = expandDeck(slidesPath, { source })
+    diagnostics.push(...expansion.diagnostics)
+    // The look in an included deck's settings counts only when it is shown
+    // alone; its palettes are the including deck's.
+    const ownOnly = new Set(['palette-contrast', 'palette-fallback'])
+    for (const file of expansion.files) {
+      const text = readFileSync(file, 'utf8')
+      for (const d of withoutSettings(text, checkDeck(file, registry, text, { includes: false }).diagnostics)) if (!ownOnly.has(d.code)) diagnostics.push({ ...d, file: d.file ?? file })
+    }
+    deck = parseSlides(expansion.source)
+  }
   // The deck's drawings file: readable, and only for slides that still exist.
   const inkPath = inkFileFor(resolve(slidesPath))
   const renamed = drawingsDiagnostic(slidesPath)
@@ -51,11 +66,17 @@ export function checkDeck(slidesPath, registry, source = readFileSync(slidesPath
 
 // What the deck's references cannot use: missing or unreadable files, an
 // unknown style or language, citations of keys the files do not have.
+// Citations in included decks are checked too, against the references they
+// bring along (include.js), and named at their file and line.
 export async function bibliographyDiagnostics(slidesPath, source = readFileSync(slidesPath, 'utf8')) {
-  const bibliography = await resolveBibliography(slidesPath, source)
+  const expansion = expandDeck(slidesPath, { source })
+  const bibliography = await resolveBibliography(slidesPath, expansion.source)
+  const texts = [[null, source], ...expansion.files.map(file => [file, readFileSync(file, 'utf8')])]
   return (bibliography?.diagnostics ?? []).map(d => {
-    const at = d.code === 'citation-unknown' ? source.indexOf('@' + d.message.match(/@(\S+)/)?.[1]) : -1
-    const line = at < 0 ? 1 : source.slice(0, at).split('\n').length
-    return { ...d, line, column: 1 }
+    const key = d.code === 'citation-unknown' ? '@' + d.message.match(/@(\S+)/)?.[1] : null
+    const [file, text] = (key && texts.find(([, text]) => text.includes(key))) || [null, source]
+    const at = key ? text.indexOf(key) : -1
+    const line = at < 0 ? 1 : text.slice(0, at).split('\n').length
+    return { ...d, line, column: 1, ...(file ? { file } : {}) }
   })
 }

package/src/build/components.js

@@ -3,10 +3,11 @@
 // file's default export is registered under its lowercased file name, so
 // `Tokenizer.jsx` becomes `<tokenizer>`. The first folder that has a name wins,
 // and all of them override built-ins of the same name.
-import { existsSync, readdirSync, readFileSync, statSync } from 'node:fs'
+import { existsSync, readdirSync, statSync } from 'node:fs'
 import { homedir } from 'node:os'
 import { resolve, dirname, basename } from 'node:path'
 import { parseSlides } from '../core/parseSlides.js'
+import { expandedSource } from './include.js'
 
 function expand(path, deckDir) {
   if (path === '~' || path.startsWith('~/')) return resolve(homedir(), path.slice(2))
@@ -14,8 +15,9 @@ function expand(path, deckDir) {
 }
 
 // Folder paths as written in the deck, resolved; entries that are not strings
-// are left to validateDeck to report.
-export function componentFolders(slidesPath, source = readFileSync(slidesPath, 'utf8')) {
+// are left to validateDeck to report. Read from the file, the folders of the
+// decks it includes count too (include.js).
+export function componentFolders(slidesPath, source = expandedSource(slidesPath)) {
   const abs = resolve(slidesPath)
   const deckDir = dirname(abs)
   let listed = []

package/src/build/homePlugin.js

@@ -1,6 +1,7 @@
 // Launch page API for `mdeck run`: what the deck contains, what `mdeck check`
-// says about it, the state of its server, and buttons that start the
-// editor and the guides or run a build. Like the editor API it answers loopback
+// says about it, the state of its server, the answers kept in the talk (to
+// save as CSV or JSON), and buttons that start the editor and the guides or
+// run a build. Like the editor API it answers loopback
 // requests from its own pages only, even when the server is shared on the
 // network for phones.
 import { spawn } from 'node:child_process'
@@ -14,6 +15,10 @@ import { roomsIn } from '../live/roomTag.js'
 import { isAllowedRequest, send, readJson } from './editorPlugin.js'
 import { findChrome } from './chrome.js'
 import { frameworkRoot } from '../paths.js'
+import { resultsFileFor, normalizeResults } from '../core/results.js'
+import { resultsReport, reportAnswersCsv, reportSummaryCsv, reportJson } from '../core/resultsReport.js'
+import { expandedSource } from './include.js'
+import { reactionsOf } from '../core/reactions.js'
 
 // Each output is one ordinary CLI run beside the deck, so the launch page
 // builds exactly what the command line would.
@@ -44,15 +49,26 @@ function reveal(file) {
   spawn(command, args, { stdio: 'ignore', detached: true }).on('error', () => {}).unref()
 }
 
-// The server named in the `server` setting: whether it answers, and whether it
-// accepts the key (MDECK_SERVER_KEY, as given to the server).
+// The server named in the `server` setting: whether it answers, whether it
+// accepts the key (MDECK_SERVER_KEY, as given to the server), and which mdeck
+// it runs (servers before 3.12 do not say).
+const VERSION = JSON.parse(readFileSync(new URL('../../package.json', import.meta.url), 'utf8')).version
+// Whether mdeck `a` is older than `b`, by major and minor: a server that
+// lacks a feature of this mdeck (reactions came with 3.12) is older.
+export function olderVersion(a, b) {
+  const [am, an] = String(a).split('.').map(Number), [bm, bn] = String(b).split('.').map(Number)
+  return am < bm || (am === bm && an < bn)
+}
+// A reachable server that runs an older mdeck than this computer, or does not say.
+const withVersion = status => status.reachable ? { ...status, version: VERSION, serverOutdated: !status.serverVersion || olderVersion(status.serverVersion, VERSION) } : status
+
 export async function liveStatus(live, { key = null, fetch: get = fetch, timeoutMs = 2500 } = {}) {
   const started = Date.now()
   try {
     const response = await get(`${live.server.replace(/\/+$/, '')}/info`, { headers: key ? { Authorization: `Bearer ${key}` } : {}, signal: AbortSignal.timeout(timeoutMs) })
     if (!response.ok) return { reachable: false, error: `It answered with status ${response.status}` }
     const body = await response.json()
-    return { reachable: true, ms: Date.now() - started, keyAccepted: key ? !!body.canReset : null }
+    return { reachable: true, ms: Date.now() - started, keyAccepted: key ? !!body.canReset : null, serverVersion: typeof body.version === 'string' ? body.version : null }
   } catch (error) {
     return { reachable: false, error: error.name === 'TimeoutError' ? `No answer within ${timeoutMs / 1000} s` : error.cause?.code ?? error.message }
   }
@@ -89,12 +105,14 @@ export function homeMiddleware(slidesPath, { urls = () => ({ local: [], network:
       theme: config.theme ?? 'neue',
       palette: config.palette ?? null,
       diagnostics: [...(registry?.warnings ?? []).map(message => ({ severity: 'warning', code: 'extension', message })), ...(registryError ? [{ severity: 'error', code: 'extension', message: registryError }] : []), ...diagnostics],
-      live: await live(config, source, { local, network }),
+      // Polls in included slides count too: the deck as shown.
+      live: await live(config, deck.source ?? source, { local, network }),
       presence: presenceUrl(config),
       // Presenting from an iPad needs an address it can reach (`--host`).
       pairing: pairing ? { available: !!relay || !!network[0], devices: pairing.devices } : null,
       relay: relay ? { url: relay.url, state: relay.state, reason: relay.reason } : null,
       chrome: !!findChrome(),
+      results: answers()?.map(({ answers: _, ...question }) => question) ?? null,
       services: Object.fromEntries(Object.keys(services).map(key => [key, serviceUrls[key] ?? null])),
       outputs: Object.fromEntries(Object.entries(outputs).map(([key, output]) => [key, {
         title: output.title,
@@ -115,27 +133,56 @@ export function homeMiddleware(slidesPath, { urls = () => ({ local: [], network:
     return typeof address === 'string' && !serverKey ? `${address.replace(/\/+$/, '')}/${room}` : `__mdeck/live/${room}`
   }
 
-  // Decks with activities, or with a server of their own, get this
+  // Decks with activities or reactions, or with a server of their own, get this
   // section: the server and its health, the join link phones open and,
   // for a server of their own, the presenter code.
   async function live(config, source, { local, network }) {
     const address = serverAddress ?? config.server
     const settings = { server: address }
     const own = typeof address === 'string'
-    if (!own && roomsIn(source).length === 0) return null
+    if (!own && roomsIn(source).length === 0 && !reactionsOf(config)) return null
     const code = sessionCode(config)
     const builtIn = base => new URL(`__mdeck/live/${code}`, base).href
     const joinUrl = own ? `${settings.server.replace(/\/+$/, '')}/${code}` : network[0] ? builtIn(network[0]) : null
     return {
       server: own ? settings.server : null,
       code,
-      ...(own ? await liveStatus(settings, { key: serverKey, fetch: get }) : { reachable: true }),
+      ...(own ? withVersion(await liveStatus(settings, { key: serverKey, fetch: get })) : { reachable: true }),
       key: own ? serverKey : null,
       joinUrl,
       localJoinUrl: joinUrl ?? (local[0] ? builtIn(local[0]) : null),
     }
   }
 
+  // The answers kept in the talk (<deck>.results.json), read against the
+  // deck as shown; null while none are kept.
+  function answers() {
+    const file = resultsFileFor(abs)
+    if (!existsSync(file)) return null
+    let results
+    try { results = normalizeResults(JSON.parse(readFileSync(file, 'utf8'))) } catch { return null }
+    if (!Object.keys(results.rooms).length) return null
+    let deck
+    try { deck = parseSlides(expandedSource(abs)) } catch { deck = parseSlides(readFileSync(abs, 'utf8')) }
+    return resultsReport(results, deck)
+  }
+
+  // GET /results?format=csv|summary|json: the answers as a file to save.
+  function download(request, response) {
+    const format = new URL(request.url, 'http://localhost').searchParams.get('format') ?? 'csv'
+    const report = answers()
+    if (!report) return send(response, 404, { error: 'No answers kept yet' })
+    const name = basename(abs).replace(/\.md$/i, '')
+    const [text, type, file] = format === 'json'
+      ? [reportJson(report, { title: parseSlides(readFileSync(abs, 'utf8')).deckConfig?.meta?.title ?? name }), 'application/json', `${name}-answers.json`]
+      : format === 'summary' ? [reportSummaryCsv(report), 'text/csv', `${name}-summary.csv`]
+      : [reportAnswersCsv(report), 'text/csv', `${name}-answers.csv`]
+    // A byte order mark, so that Excel reads the words as UTF-8.
+    const body = type === 'text/csv' ? `\uFEFF${text}` : text
+    response.writeHead(200, { 'Content-Type': `${type}; charset=utf-8`, 'Content-Disposition': `attachment; filename="${file}"`, 'Content-Length': Buffer.byteLength(body), 'Cache-Control': 'no-store', 'X-Content-Type-Options': 'nosniff' })
+    response.end(body)
+  }
+
   // Each service starts once; a failed start can be retried.
   async function start(key) {
     started[key] ??= services[key]().then(service => { serviceUrls[key] = service.url; return service }, error => { delete started[key]; throw error })
@@ -144,18 +191,20 @@ export function homeMiddleware(slidesPath, { urls = () => ({ local: [], network:
 
   // The one-time address an iPad opens to present from: the presenter view,
   // with a one-time pairing offer; the server's master key stays here.
-  function pairUrl() {
+  // `layout: 'remote'` opens it as the phone clicker instead.
+  function pairUrl(layout = 'slide') {
     const network = relay?.url ?? urls()?.network?.[0]
     if (!pairing || !network) throw Object.assign(new Error('Start mdeck run with --network or --server so an iPad can reach it'), { status: 409 })
     const url = new URL(network)
     url.searchParams.set('view', 'presenter')
+    url.searchParams.set('layout', layout === 'remote' ? 'remote' : 'slide')
     url.searchParams.set('pair', pairing.offer())
     return url.href
   }
 
-  async function act({ action, output } = {}) {
+  async function act({ action, output, layout } = {}) {
     if (Object.hasOwn(services, action)) return { url: await start(action) }
-    if (action === 'pair') return { url: pairUrl() }
+    if (action === 'pair') return { url: pairUrl(layout) }
     if (action === 'unpair') { pairing?.revoke(); return { ok: true } }
     if (action === 'build') {
       if (!Object.hasOwn(outputs, output)) throw Object.assign(new Error(`Unknown output: ${output}`), { status: 400 })
@@ -176,12 +225,13 @@ export function homeMiddleware(slidesPath, { urls = () => ({ local: [], network:
 
   return async (request, response, next) => {
     const pathname = new URL(request.url, 'http://localhost').pathname
-    if (!['/info', '/action'].includes(pathname)) return next()
+    if (!['/info', '/action', '/results'].includes(pathname)) return next()
     if (!isAllowedRequest(request)) return send(response, 403, { error: 'The launch page only answers on this computer' })
     try {
+      if (pathname === '/results' && request.method === 'GET') return download(request, response)
       if (pathname === '/info' && request.method === 'GET') return send(response, 200, await info(request))
       if (pathname === '/action' && request.method === 'POST') return send(response, 200, await act(await readJson(request)))
-      response.setHeader('Allow', pathname === '/info' ? 'GET' : 'POST')
+      response.setHeader('Allow', pathname === '/action' ? 'POST' : 'GET')
       return send(response, 405, { error: 'Method not allowed' })
     } catch (error) {
       return send(response, error.status ?? 500, { error: error.message })