mdeck 3.10.1 → 3.12.0

package/src/build/timingPlugin.js

@@ -0,0 +1,96 @@
+// Saving a rehearsal's times while `mdeck run` runs: the presenter view
+// sends each slide's new time, and it goes into the slide's settings as
+// `time: 1m30s` (core/timing.js). null takes a slide's time out.
+//
+//   GET  /__mdeck/timing   → { ids }
+//   POST /__mdeck/timing   { ids, times: { [slideId]: '1m30s' | null } } → { ok, changed }
+//
+// Slides without an `id:` are named by position (slide-3), so the times are
+// only written when the deck still has the slides the page saw (`ids`);
+// otherwise the answer is 409. The deck is copied to .mdeck-backups/ before
+// the first write, and the write does not reload the open windows
+// (ownWrites.js). A slide from another file the deck includes (include.js)
+// gets its time in that file, as that file's own slide.
+import { readFileSync, writeFileSync, renameSync } from 'node:fs'
+import { resolve } from 'node:path'
+import { parseSlides } from '../core/parseSlides.js'
+import { setSlideMeta } from '../core/editDeck.js'
+import { parseTime, formatTime } from '../core/timing.js'
+import { isAllowedRequest, send, readJson, backupDeck } from './editorPlugin.js'
+import { markOwnWrite } from './ownWrites.js'
+import { expandDeck } from './include.js'
+
+export function createTimingFile(deckPath) {
+  const abs = resolve(deckPath)
+  const backedUp = new Set()
+  // The deck as shown, and for each slide the file it is written in.
+  const shown = () => {
+    const { source, origins } = expandDeck(abs)
+    return { deck: parseSlides(source), origins }
+  }
+
+  return {
+    path: abs,
+    ids: () => shown().deck.slides.map(slide => slide.id),
+    save(ids, times) {
+      const { deck: whole, origins } = shown()
+      const current = whole.slides.map(slide => slide.id)
+      if (!Array.isArray(ids) || ids.join('\n') !== current.join('\n')) return { status: 409, error: 'The deck changed since the rehearsal began; rehearse again', ids: current }
+      // The new times, by the file the slide is written in and its id there.
+      const files = new Map()
+      for (const [id, value] of Object.entries(times ?? {})) {
+        if (!current.includes(id)) return { status: 400, error: `No slide "${id}" in the deck` }
+        const seconds = value == null ? null : parseTime(value)
+        if (value != null && seconds == null) return { status: 400, error: `"${value}" is not a time` }
+        const time = seconds == null ? undefined : formatTime(seconds)
+        if (whole.slides.find(slide => slide.id === id).meta.time === time) continue
+        const { file, id: own } = origins?.[id] ?? { file: abs, id }
+        if (!files.has(file)) files.set(file, [])
+        files.get(file).push([own, time])
+      }
+      let changed = 0
+      for (const [file, entries] of files) {
+        const before = readFileSync(file, 'utf8')
+        let source = before, deck = parseSlides(source)
+        for (const [id, time] of entries) {
+          source = setSlideMeta(deck, id, { time })
+          deck = parseSlides(source)
+          changed++
+        }
+        if (source === before) continue
+        if (!backedUp.has(file)) { backupDeck(file, before); backedUp.add(file) }
+        markOwnWrite(file, source)
+        const temp = `${file}.${process.pid}.tmp`
+        writeFileSync(temp, source, 'utf8')
+        renameSync(temp, file)
+      }
+      return { status: 200, ok: true, changed }
+    },
+  }
+}
+
+export function timingMiddleware(file, { authorize = isAllowedRequest } = {}) {
+  return async (request, response, next) => {
+    const { pathname } = new URL(request.url, 'http://localhost')
+    if (pathname !== '/') return next()
+    if (!authorize(request)) return send(response, 403, { error: 'Only the presenter can save times' })
+    try {
+      if (request.method === 'GET') return send(response, 200, { ids: file.ids() })
+      if (request.method !== 'POST') { response.setHeader('Allow', 'GET, POST'); return send(response, 405, { error: 'Method not allowed' }) }
+      const { ids, times } = await readJson(request)
+      const { status, ...result } = file.save(ids, times)
+      return send(response, status, result)
+    } catch (error) {
+      return send(response, error.status ?? 500, { error: error.message })
+    }
+  }
+}
+
+export function timingPlugin(slidesPath, { authorize } = {}) {
+  return {
+    name: 'vite-plugin-mdeck-timing',
+    configureServer(server) {
+      server.middlewares.use('/__mdeck/timing', timingMiddleware(createTimingFile(slidesPath), { authorize }))
+    },
+  }
+}

package/src/cli/args.js

@@ -4,14 +4,15 @@ const common = { '--port': value, '--no-open': flag }
 const output = { '--output': value, '-o': '--output', '--no-drawings': flag, '--no-results': flag }
 const commands = {
   new: { max: 0 },
-  run: { ...common, '--network': flag, '--server': optional, max: 1 },
+  run: { ...common, '--network': flag, '--server': optional, '--no-server': flag, max: 1 },
+  rehearse: { ...common, '--network': flag, '--server': optional, '--no-server': flag, max: 1 },
   edit: { ...common, max: 1 },
   design: { ...common, max: 1 },
   themes: { '--local': flag, '--force': flag, '--check': flag, '--output': value, '-o': '--output', max: 4 },
   palettes: { '--local': flag, '--force': flag, max: 4 },
-  build: { ...output, '--single-file': flag, '--launchers': flag, '--reader': flag, '--notes': flag, '--no-polls': flag, max: 1 },
-  send: { ...output, '--notes': flag, '--no-polls': flag, '--no-pdf': flag, max: 1 },
-  pdf: { ...output, '--no-polls': flag, max: 1 },
+  build: { ...output, '--single-file': flag, '--launchers': flag, '--reader': flag, '--notes': flag, '--no-polls': flag, '--slide': value, max: 1 },
+  send: { ...output, '--notes': flag, '--no-polls': flag, '--no-pdf': flag, '--slide': value, max: 1 },
+  pdf: { ...output, '--no-polls': flag, '--slide': value, max: 1 },
   preview: { ...common, max: 1 },
   check: { '--strict': flag, '--render': flag, max: 1 },
   snapshot: { '--output': value, '-o': '--output', '--slide': value, '--dark': flag, '--light': flag, '--sheet': flag, max: 1 },
@@ -21,7 +22,7 @@ const commands = {
   server: { '--port': value, '--host': optional, max: 0 },
   skill: { '--print': flag, '--install': 'list', '--project': flag, max: 0 },
   migrate: { '--dry-run': flag, max: 1 },
-  results: { '--output': value, '-o': '--output', max: 1 },
+  results: { '--output': value, '-o': '--output', '--summary': flag, '--json': flag, max: 1 },
 }
 
 export function validateServerOrigin(address) {

package/src/cli/index.js

@@ -13,9 +13,11 @@ import { BACKUP_DIR } from '../build/editorPlugin.js'
 import { createEditorServer, createDesignServer } from '../build/editorServer.js'
 import { homePlugin } from '../build/homePlugin.js'
 import { checkDeck, bibliographyDiagnostics } from '../build/check.js'
+import { expandedSource } from '../build/include.js'
 import { livePlugin, startLiveServer } from '../live/server.js'
 import { inkPlugin } from '../build/inkPlugin.js'
 import { resultsPlugin } from '../build/resultsPlugin.js'
+import { timingPlugin } from '../build/timingPlugin.js'
 import { createPairing, pairingPlugin } from '../build/pairing.js'
 import { isAllowedRequest } from '../build/editorPlugin.js'
 import { renderPdf, attachPdf, findChrome } from '../build/pdf.js'
@@ -26,10 +28,11 @@ import { paramKind } from '../extensions/params.js'
 
 import { frameworkRoot } from '../paths.js'
 import { parseSlides } from '../core/parseSlides.js'
-import { stripNotes as stripNotesFrom, stripActivities as stripActivitiesFrom } from '../core/editDeck.js'
+import { stripNotes as stripNotesFrom, shareSlides } from '../core/editDeck.js'
 import { parseArgs, parseSlideNumbers, validateServerOrigin } from './args.js'
 import { assertDrawings } from '../build/drawings.js'
-import { resultsFileFor, normalizeResults, resultsCsv } from '../core/results.js'
+import { resultsFileFor, normalizeResults } from '../core/results.js'
+import { resultsReport, reportAnswersCsv, reportSummaryCsv, reportJson } from '../core/resultsReport.js'
 import { createRelayAccess } from '../build/relayAccess.js'
 import { sessionCode } from '../live/code.js'
 import { migrateDeck } from './migrate.js'
@@ -58,7 +61,25 @@ function hasFlag(name, short = null) { return !!(parsed.options[name] ?? parsed.
 const positionals = () => parsed.positionals
 const outputOption = () => parsed.options['--output'] ?? null
 const serverOption = () => parsed.options['--server']
+// Whether a poll server answers at `address`, within a few seconds.
+async function serverAnswers(address) {
+  try {
+    validateServerOrigin(address)
+    const response = await fetch(new URL('info', address.replace(/\/*$/, '/')), { signal: AbortSignal.timeout(3000) })
+    return response.ok
+  } catch { return false }
+}
 const portOption = () => parsed.options['--port'] ?? null
+// --slide 3,5-7 for build, send and pdf: only these slides, numbered as written.
+function slideOption(input) {
+  const given = parsed.options['--slide']
+  if (given == null) return null
+  try {
+    const slides = parseSlideNumbers(given)
+    shareSlides(readFileSync(resolve(input), 'utf-8'), { slides })
+    return slides
+  } catch (error) { err(error.message); process.exit(1) }
+}
 
 // Layouts, themes and palettes all come from one registry: built-ins plus the
 // extensions/ folder beside the deck. Manifest problems are reported and stop
@@ -181,13 +202,14 @@ async function runNewWizard() {
   }
 }
 
-async function copyLocalAssets(slidesPath, outDir, { stripNotes = false, stripActivities = false } = {}) {
+async function copyLocalAssets(slidesPath, outDir, { stripNotes = false, stripActivities = false, slides = null } = {}) {
   const absSlides = resolve(slidesPath)
   const deckDir = dirname(absSlides)
   const absOutDir = resolve(outDir)
-  const raw = readFileSync(absSlides, 'utf-8')
+  // The deck as shown: pictures of included slides are copied too.
+  const raw = expandedSource(absSlides)
   let markdown = stripNotes ? stripNotesFrom(raw) : raw
-  if (stripActivities) markdown = stripActivitiesFrom(markdown).source
+  if (stripActivities || slides) markdown = shareSlides(markdown, { activities: stripActivities, slides }).source
 
   for (const ref of collectLocalAssetRefs(markdown)) {
     const source = resolve(deckDir, ref)
@@ -312,8 +334,13 @@ const HELP = `
       --network              reach the slides from phones and tablets on the same network
       --server [address]     present from an iPad on any network, through your server
                              (the address, or the deck's server setting, or MDECK_SERVER;
-                              the key in MDECK_SERVER_KEY)
+                              the key in MDECK_SERVER_KEY). With both MDECK_SERVER and
+                              MDECK_SERVER_KEY set, the server is used without --server
+                              when it answers
+      --no-server            present from this computer only, even with MDECK_SERVER set
       --no-open   --port <number>
+    ${c.green}mdeck rehearse${c.reset} [slides.md]                Like run, but opens the presenter view rehearsing: it times
+                                              each slide and saves the times into the deck (time: 1m30s)
     ${c.green}mdeck edit${c.reset} [slides.md]                    Edit slides in the browser; saves to the file
     ${c.green}mdeck design${c.reset} [folder | slides.md]         Look at and fine-tune themes and palettes on a sample deck;
                                               saves to the folder's extensions/ (default: this folder)
@@ -332,6 +359,8 @@ const HELP = `
       --notes                keep the speaker notes in the file
       --no-polls             for send, build --reader and pdf: leave out the slides with polls and join codes
       --no-pdf               do not render the PDF inside
+      --slide 3,5-7          for build, send and pdf: only these slides (numbered as in the deck,
+                             with their drawings; styles from slides left out stay)
     ${c.green}mdeck pdf${c.reset} [slides.md] [-o talk.pdf]       A PDF, one page per slide
       --no-drawings          for build, send and pdf: leave out <slides>.drawings.json
       --no-results           for build, send and pdf: leave out <slides>.results.json (the answers kept in the talk)
@@ -346,7 +375,9 @@ const HELP = `
       --slide <numbers>      only these slides: 3, 3,5 or 2-4
       --sheet                one picture of them all in a grid, each under its number and heading
       --dark | --light       in this appearance instead of the deck's own   -o <folder>
-    ${c.green}mdeck results${c.reset} [slides.md] [-o answers.csv]  The answers kept in the talk, as CSV (room, phone, time, answer)
+    ${c.green}mdeck results${c.reset} [slides.md] [-o answers.csv]  The answers kept in the talk, as CSV: slide, question, phone, time, answer
+      --summary              one row per option, number or word, with how many chose it
+      --json                 everything as JSON: each question, its summary and its answers (also -o answers.json)
     ${c.green}mdeck list${c.reset} [layouts|themes|palettes] [slides.md] [--json]
                                               List built-in and deck-local layouts, themes and palettes
     ${c.green}mdeck starter${c.reset} <layout> [slides.md]        Print starter Markdown for a layout
@@ -402,7 +433,7 @@ if (argv.includes('--help') || argv.includes('-h')) { console.log(HELP); process
 let parsed
 try {
   parsed = parseArgs(command, argv)
-  if (['run', 'server'].includes(command) && Object.hasOwn(process.env, 'MDECK_LIVE_KEY')) throw new Error('MDECK_LIVE_KEY is now MDECK_SERVER_KEY. Rename the environment variable before starting mdeck.')
+  if (['run', 'rehearse', 'server'].includes(command) && Object.hasOwn(process.env, 'MDECK_LIVE_KEY')) throw new Error('MDECK_LIVE_KEY is now MDECK_SERVER_KEY. Rename the environment variable before starting mdeck.')
 } catch (error) {
   err(error.message)
   if (Object.hasOwn(RENAMED_COMMANDS, command)) tip(`mdeck ${command} is now ${RENAMED_COMMANDS[command]}.`)
@@ -476,11 +507,18 @@ if (command === 'new') {
   const input = requireInput('results')
   const file = resultsFileFor(resolve(input))
   if (!existsSync(file)) { err(`No answers kept for ${basename(input)} yet: ${basename(file)} appears beside it once people answer during mdeck run.`); process.exit(1) }
-  let csv
-  try { csv = resultsCsv(normalizeResults(JSON.parse(readFileSync(file, 'utf8')))) } catch (error) { err(`${basename(file)}: ${error.message}`); process.exit(1) }
+  let results
+  try { results = normalizeResults(JSON.parse(readFileSync(file, 'utf8'))) } catch (error) { err(`${basename(file)}: ${error.message}`); process.exit(1) }
+  // Read against the deck as shown, included slides too, for the slide and the question.
+  let deck
+  try { deck = parseSlides(expandedSource(resolve(input))) } catch { deck = parseSlides(readFileSync(resolve(input), 'utf8')) }
+  const report = resultsReport(results, deck)
   const out = outputOption()
-  if (out) { writeFileSync(out, csv); ok(`Saved ${relative(process.cwd(), resolve(out))}`) }
-  else process.stdout.write(csv)
+  const json = hasFlag('--json') || /\.json$/i.test(out ?? '')
+  const text = json ? reportJson(report, { title: deck.deckConfig?.meta?.title ?? basename(input).replace(/\.md$/i, '') })
+    : hasFlag('--summary') ? reportSummaryCsv(report) : reportAnswersCsv(report)
+  if (out) { writeFileSync(out, text); ok(`Saved ${relative(process.cwd(), resolve(out))}`) }
+  else process.stdout.write(text)
 } else if (command === 'check') {
   const input = requireInput('check')
   const registry = registryFor(input)
@@ -538,7 +576,7 @@ if (command === 'new') {
   else process.stdout.write(layouts[name].starter)
 
 // ── run ───────────────────────────────────────────────────────────────────────
-} else if (command === 'run') {
+} else if (command === 'run' || command === 'rehearse') {
   const input = requireInput(command)
   const abs = resolve(input)
   try { assertDrawings(abs) } catch (error) { err(error.message); process.exit(1) }
@@ -550,8 +588,18 @@ if (command === 'new') {
   // (src/build/tunnelClient.js). The dev server then serves under /t/<id>/, the
   // address the iPad uses on the server, and its own addresses follow it. The
   // address is the flag's value, else the deck's server setting, else MDECK_SERVER.
+  // With MDECK_SERVER and MDECK_SERVER_KEY set, the server is used without
+  // --server when it answers; otherwise this computer presents alone.
+  // --no-server keeps it out.
   let relay = null
-  const serverFlag = serverOption()
+  let serverFlag = serverOption()
+  if (serverFlag === undefined && !hasFlag('--no-server') && process.env.MDECK_SERVER && process.env.MDECK_SERVER_KEY) {
+    const address = process.env.MDECK_SERVER
+    if (await serverAnswers(address)) {
+      serverFlag = address
+      tip(`Using your server from MDECK_SERVER (${address}); --no-server presents without it.`)
+    } else tip(`Your server (MDECK_SERVER, ${address}) does not answer: presenting from this computer only.`)
+  }
   if (serverFlag !== undefined) {
     const inDeck = parseSlides(readFileSync(abs, 'utf8')).deckConfig?.server
     const address = serverFlag ?? (typeof inDeck === 'string' ? inDeck : null) ?? process.env.MDECK_SERVER ?? null
@@ -584,13 +632,13 @@ if (command === 'new') {
     ...base,
     // A paired iPad may save ink and steer the rooms, like this computer.
     ...(relay ? { base: relay.base } : {}),
-    plugins: [...(relay ? [stripRelayBase(relay.base)] : []), ...base.plugins, homePlugin(abs, { services, pairing, relay, server: relay?.server ?? null }), pairingPlugin(pairing), livePlugin({ pairing, upstream, key: process.env.MDECK_SERVER_KEY, session: () => sessionCode(parseSlides(readFileSync(abs, 'utf8')).deckConfig) }), inkPlugin(abs, { authorize: request => isAllowedRequest(request) || pairing.allows(request) }), resultsPlugin(abs, { authorize: request => isAllowedRequest(request) || pairing.allows(request) })],
+    plugins: [...(relay ? [stripRelayBase(relay.base)] : []), ...base.plugins, homePlugin(abs, { services, pairing, relay, server: relay?.server ?? null }), pairingPlugin(pairing), livePlugin({ pairing, upstream, key: process.env.MDECK_SERVER_KEY, session: () => sessionCode(parseSlides(readFileSync(abs, 'utf8')).deckConfig) }), inkPlugin(abs, { authorize: request => isAllowedRequest(request) || pairing.allows(request) }), resultsPlugin(abs, { authorize: request => isAllowedRequest(request) || pairing.allows(request) }), timingPlugin(abs, { authorize: request => isAllowedRequest(request) || pairing.allows(request) })],
     publicDir: dirname(abs),
     server: {
       ...base.server,
       ...(port ? { port, strictPort: true } : {}),
       host: exposed ? true : base.server.host,
-      open: hasFlag('--no-open') ? false : `${mountBase}home.html`,
+      open: hasFlag('--no-open') ? false : command === 'rehearse' ? `${mountBase}?view=presenter&rehearse=1` : `${mountBase}home.html`,
     },
   })
   await server.listen()
@@ -624,11 +672,12 @@ if (command === 'new') {
   console.log()
   ok(`Launch page: ${c.cyan}${new URL('home.html', local).href}${c.reset}`)
   tip(`Presenter:   ${new URL('?view=presenter', local).href}`)
+  tip(`Rehearse:    ${new URL('?view=presenter&rehearse=1', local).href}`)
   tip(`Audience:    ${new URL('?view=audience', local).href}`)
   // Phones in the room follow the talk (the reader view would show slides ahead).
   if (exposed) for (const url of server.resolvedUrls.network) tip(`Follow:      ${new URL('?view=follow', url).href}`)
   console.log()
-  if (relay) tip(`iPad:        choose "Show pairing code" on the launch page; it opens ${relay.url}`)
+  if (relay) tip(`iPad:        in the presenter view, click the connection icons and choose "iPad" or "Phone clicker"; it opens ${relay.url}`)
   ok(`Watching ${c.cyan}${abs}${c.reset}`)
   tip('Edit and save to reload.\n')
 
@@ -696,6 +745,7 @@ if (command === 'new') {
   // Polls show as a record of the talk; --no-polls leaves their slides and join codes out.
   const stripActivities = reader && hasFlag('--no-polls')
   const wantPdf = sending && !hasFlag('--no-pdf')
+  const slides = slideOption(input)
 
   if (!hasFlag('--no-drawings')) { try { assertDrawings(input) } catch (error) { err(error.message); process.exit(1) } }
   const given = outputOption()
@@ -709,7 +759,7 @@ if (command === 'new') {
   try {
     await build({
       ...baseConfig(input, { selfContained, defaultView: reader ? 'reader' : 'deck' }),
-      plugins: [preact(), slidesPlugin(resolve(input), { inlineImages: selfContained, inlineMedia: selfContained, embedFonts: selfContained, stripNotes, stripActivities, ink: !hasFlag('--no-drawings'), results: !hasFlag('--no-results'), deckLook: reader }), viteSingleFile()],
+      plugins: [preact(), slidesPlugin(resolve(input), { inlineImages: selfContained, inlineMedia: selfContained, embedFonts: selfContained, stripNotes, stripActivities, slides, ink: !hasFlag('--no-drawings'), results: !hasFlag('--no-results'), deckLook: reader }), viteSingleFile()],
       build: {
         outDir,
         emptyOutDir: !tempDir,
@@ -727,7 +777,7 @@ if (command === 'new') {
   await mkdir(finalOutDir, { recursive: true })
 
   if (!selfContained) {
-    await copyLocalAssets(input, finalOutDir, { stripNotes, stripActivities })
+    await copyLocalAssets(input, finalOutDir, { stripNotes, stripActivities, slides })
     if (launchers) await writePresenterLaunchers(finalOutDir, htmlFilename)
   }
 
@@ -751,7 +801,12 @@ if (command === 'new') {
     } finally { await rm(pdfDir, { recursive: true, force: true }) }
   }
   if (stripNotes) tip('Speaker notes were removed from this file (use --notes to keep them).')
-  if (stripActivities && stripActivitiesFrom(readFileSync(resolve(input), 'utf-8')).removed.length) tip('Slides with polls were left out (--no-polls).')
+  // Only polls among the slides chosen with --slide were left out for --no-polls.
+  if (stripActivities) {
+    const raw = readFileSync(resolve(input), 'utf-8')
+    if (shareSlides(raw, { activities: true, slides }).removed.length > (slides ? shareSlides(raw, { slides }).removed.length : 0)) tip('Slides with polls were left out (--no-polls).')
+  }
+  if (slides) tip(`Only slides ${parsed.options['--slide']} (--slide).`)
   ok(`${sending ? 'Made' : 'Built'}: ${c.cyan}${htmlFile}${c.reset}${reader ? ' — opens in the reader view' : ''}${selfContained ? ' (single file)' : ' + local assets'}\n`)
 
 // ── skill ─────────────────────────────────────────────────────────────────────
@@ -777,11 +832,12 @@ if (command === 'new') {
   const pdfFile = resolve(process.cwd(), outputOption() ?? basename(input).replace(/\.md$/i, '') + '.pdf')
   if (!hasFlag('--no-drawings')) { try { assertDrawings(input) } catch (error) { err(error.message); process.exit(1) } }
   if (!findChrome()) { err('No Chrome or Chromium found. Set MDECK_CHROME to its executable path.'); process.exit(1) }
+  const slides = slideOption(input)
   const tempDir = mkdtempSync(resolve(tmpdir(), 'mdeck-pdf-'))
   try {
     await build({
       ...baseConfig(input, { selfContained: true }),
-      plugins: [preact(), slidesPlugin(resolve(input), { inlineImages: true, inlineMedia: true, embedFonts: true, stripActivities: hasFlag('--no-polls'), ink: !hasFlag('--no-drawings'), results: !hasFlag('--no-results'), deckLook: true }), viteSingleFile()],
+      plugins: [preact(), slidesPlugin(resolve(input), { inlineImages: true, inlineMedia: true, embedFonts: true, stripActivities: hasFlag('--no-polls'), slides, ink: !hasFlag('--no-drawings'), results: !hasFlag('--no-results'), deckLook: true }), viteSingleFile()],
       build: { outDir: tempDir, emptyOutDir: true, target: 'esnext', assetsInlineLimit: 100 * 1024 * 1024 },
       logLevel: 'warn',
     })

package/src/components/Bibliography.jsx

@@ -4,6 +4,9 @@ import { currentBibliography, onBibliography } from '../runtime/citations.js'
 // <bibliography /> on a slide: the deck's reference list, the works it cites
 // plus `nocite`, in the citation style's order. A long list goes over several
 // slides with <bibliography part="1/2" /> and <bibliography part="2/2" />.
+// `keys="a b"` lists only these works; in a deck that includes another, that
+// deck's own list gets the keys it cites (build/include.js), so it shows what
+// it shows alone.
 
 function slice(order, part) {
   const match = String(part ?? '').match(/^\s*(\d+)\s*\/\s*(\d+)\s*$/)
@@ -14,10 +17,12 @@ function slice(order, part) {
   return order.slice((index - 1) * size, index * size)
 }
 
-export default function Bibliography({ part }) {
+export default function Bibliography({ part, keys }) {
   const [bib, setBib] = useState(currentBibliography)
   useEffect(() => onBibliography(setBib), [])
   if (!bib) return <p class="bibliography-hint">Name a reference file in the deck settings, e.g. <code>bibliography: refs.bib</code>.</p>
-  const html = slice(bib.order, part).map(id => bib.entries[id]).join('')
+  const only = keys == null ? null : new Set(String(keys).split(/[\s,]+/).map(key => key.replace(/^@/, '')).filter(Boolean))
+  const order = only ? bib.order.filter(id => only.has(id)) : bib.order
+  const html = slice(order, part).map(id => bib.entries[id]).join('')
   return <div class="bibliography csl-bib-body" dangerouslySetInnerHTML={{ __html: html }} />
 }

package/src/components/Poll.jsx

@@ -7,8 +7,8 @@ import { pollChoices } from '../core/pollList.js'
 import './poll.css'
 
 // <poll room="lunch" question="Where do we eat?" options="Mensa|Thai|Pizza" />
-// On the slide: live bars, the number of answers and the deck's join code
-// (`qr="false"` leaves it out, when the code was on an earlier slide).
+// On the slide: live bars and the number of answers; the deck's join code
+// beside them only with `qr` (the presenter shows it over the slide, J).
 // On the phones, the server's answer page shows one button per option,
 // as described by Poll.phone. Each device has one vote and can change it; the
 // latest one counts.

package/src/components/QrCodeTag.jsx

@@ -7,8 +7,8 @@ import './poll.css'
 
 // <qrcode url="https://example.com" size="240" /> on a slide.
 // <qrcode join />: the deck's join link for audience questions, with the
-// short link below it, so a slide early in the talk can invite everyone once
-// and the questions after it can leave out their own code (`qr="false"`).
+// short link below it, for a slide that invites everyone (the presenter view
+// can also put it over any slide, J).
 // <qrcode follow />: the link for following the slides on a phone or laptop.
 
 function JoinQr({ size }) {

package/src/components/VideoPlayer.jsx

@@ -169,7 +169,12 @@ export default function VideoPlayer({ src, url, play = 'click', aspect, muted })
     >
       {url ? (
         iframeSrc
-          ? <iframe src={iframeSrc} allow="autoplay; fullscreen" allowFullScreen
+          // A deck served through a server (an iPad paired over the internet)
+          // comes with "Referrer-Policy: no-referrer", so pairing links never
+          // leak; YouTube refuses to play an embed that names no page
+          // ("This video is unavailable"). The player alone sends the
+          // deck's origin, never its path.
+          ? <iframe src={iframeSrc} allow="autoplay; fullscreen" allowFullScreen referrerpolicy="strict-origin"
               style={{ width: '100%', height: fixedAspect ? '100%' : 'auto', aspectRatio: fixedAspect ? undefined : '16 / 9', border: '0', display: 'block' }} />
           : <div class="video-player-placeholder" />
       ) : (

package/src/components/WordCloud.jsx

@@ -1,15 +1,15 @@
 import { h } from 'preact'
 import { useEffect, useMemo, useRef, useState } from 'preact/hooks'
 import cloud from 'd3-cloud'
-import { useRoom } from '../live/client.js'
+import { useRoom, latestByDevice } from '../live/client.js'
 import { JoinCode, ActivityFooter, ActivityQuestion, ActivityControls, useControls, wantsQr } from './activity.jsx'
 import { phoneQuestion } from './inlineText.js'
 import { t } from '../core/labels.js'
 import './poll.css'
 
 // <wordcloud room="mood" question="One word for today?" />
-// Phones send a word or two, as often as they like. The slide packs every
-// answer into a cloud around its middle: the more often it was sent, the
+// Each phone sends a word or two; a new one replaces its earlier word. The
+// slide packs the answers into a cloud around its middle: the more often it was sent, the
 // larger; some stand upright. Answers that differ only in case or spacing
 // count together. `height` is the cloud's height in slide pixels (520),
 // `limit` the most words shown (60).
@@ -66,7 +66,7 @@ function layout(words, { width, height, font }) {
 export default function WordCloud({ room = 'words', question = '', limit = '60', height = '520', qr }) {
   const live = useRoom(room)
   const controls = useControls(room, live)
-  const all = countWords(controls.counted(live.messages))
+  const all = countWords(latestByDevice(controls.counted(live.messages)))
   const words = all.slice(0, Math.max(1, Number(limit) || 60))
   const total = all.reduce((sum, word) => sum + word.n, 0)
   const cloudHeight = Math.max(200, Number(height) || 520)
@@ -99,7 +99,7 @@ export default function WordCloud({ room = 'words', question = '', limit = '60',
           </svg>
           : !live.offline && <p class="question-empty">{t('question.empty')}</p>}
       </div>
-      <ActivityFooter count={total} {...live} reset={controls.reset} closed={controls.closed}>
+      <ActivityFooter count={total} {...live} perPhone reset={controls.reset} closed={controls.closed}>
         <ActivityControls controls={controls} messages={live.messages} offline={live.offline} />
       </ActivityFooter>
     </div>
@@ -107,4 +107,5 @@ export default function WordCloud({ room = 'words', question = '', limit = '60',
   </div>
 }
 
-WordCloud.phone = ({ question, placeholder }, { slideTitle = '' } = {}) => ({ type: 'text', ...phoneQuestion(question, slideTitle), placeholder: placeholder ?? '', maxLength: 40 })
+// `once`: the phone's latest word counts (a server before 3.12 ignores it and lets phones send more).
+WordCloud.phone = ({ question, placeholder }, { slideTitle = '' } = {}) => ({ type: 'text', ...phoneQuestion(question, slideTitle), placeholder: placeholder ?? '', maxLength: 40, once: true })

package/src/components/activity.jsx

@@ -12,9 +12,10 @@ import 'katex/dist/katex.min.css'
 // the number of answers, the live dot, Reset and the presenter's controls.
 
 export const shortLink = url => url.replace(/^https?:\/\//, '')
-// `qr="false"` (or "no", "off") leaves the code out: it was on an earlier
-// slide (<qrcode join />), and people's phones follow along.
-export const wantsQr = qr => !/^(false|no|off|0)$/i.test(String(qr ?? 'true'))
+// An activity shows no join code of its own: the presenter puts it over the
+// slide when it is wanted (J), and phones that joined follow along. `qr` (or
+// `qr="true"`) still puts the code beside the question.
+export const wantsQr = qr => qr != null && !/^(false|no|off|0)$/i.test(String(qr))
 // A switch such as `multiple`: on when given, unless it says false.
 export const isSet = value => value != null && !/^(false|no|off|0)$/i.test(String(value))
 
@@ -86,11 +87,13 @@ export function useControls(room, live, { results = true, solution = null } = {}
  * A record of the talk (`offline`) can still show the answer and results.
  */
 export function ActivityControls({ controls, messages, offline = false, results = false, solve = false }) {
-  const button = (name, on, label, onClick, icon) => <button type="button" class={`poll-control poll-${name}${on ? ' is-on' : ''}`} title={label} aria-label={label} aria-pressed={on} onClick={onClick}>{icon}</button>
+  // data-presenter-control: the phone clicker offers them too (runtime/slideControls.js).
+  const button = (name, on, label, onClick, icon, iconName) => <button type="button" class={`poll-control poll-${name}${on ? ' is-on' : ''}`} title={label} aria-label={label} aria-pressed={on} data-presenter-control="" data-presenter-icon={iconName} onClick={onClick}>{icon}</button>
+  const lock = controls.closed ? 'lock' : 'lock-open', eye = controls.results ? 'eye' : 'eye-off'
   return <>
-    {!offline && button('close', controls.closed, t(controls.closed ? 'poll.open' : 'poll.close'), () => controls.close(messages), <Icon name={controls.closed ? 'lock' : 'lock-open'} size={22} />)}
-    {results && button('results', !controls.results, t(controls.results ? 'poll.hideResults' : 'poll.showResults'), () => controls.change({ results: !controls.results }), <Icon name={controls.results ? 'eye' : 'eye-off'} size={24} />)}
-    {solve && button('solve', controls.revealed, t(controls.revealed ? 'poll.hideAnswer' : 'poll.showAnswer'), () => controls.change({ revealed: !controls.revealed }), <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2.4" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><path d="M5 12l5 5 9-10" /></svg>)}
+    {!offline && button('close', controls.closed, t(controls.closed ? 'poll.open' : 'poll.close'), () => controls.close(messages), <Icon name={lock} size={22} />, lock)}
+    {results && button('results', !controls.results, t(controls.results ? 'poll.hideResults' : 'poll.showResults'), () => controls.change({ results: !controls.results }), <Icon name={eye} size={24} />, eye)}
+    {solve && button('solve', controls.revealed, t(controls.revealed ? 'poll.hideAnswer' : 'poll.showAnswer'), () => controls.change({ revealed: !controls.revealed }), <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2.4" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><path d="M5 12l5 5 9-10" /></svg>, 'check')}
   </>
 }
 
@@ -110,7 +113,7 @@ export function ActivityFooter({ count, connected, canReset, reset, offline, pre
     {of != null ? t('poll.answeredOf', { n: count, of }) : count === 1 ? t('poll.answer') : t('poll.answers', { n: count })}
     {closed && <span class="poll-closed">{t('poll.closed')}</span>}
     <span class="poll-spacer" />
-    {canReset && <button class="poll-reset" disabled={count === 0 && !closed} onClick={() => reset().catch(() => {})}>{t('poll.reset')}</button>}
+    {canReset && <button class="poll-reset" disabled={count === 0 && !closed} data-presenter-control="" data-presenter-icon="reset" aria-label={t('poll.reset')} onClick={() => reset().catch(() => {})}>{t('poll.reset')}</button>}
     {children}
   </p>
 }

package/src/components/poll.css

@@ -31,6 +31,8 @@ deck-stage[data-follower] .poll-reset { display: none; }
 .poll-control:hover, .poll-control:focus-visible { opacity: 1; }
 .poll-close.is-on, .poll-results.is-on { opacity: 1; background: var(--muted, #666); border-color: var(--muted, #666); color: #fff; }
 deck-stage[data-follower] .poll-control { display: none; }
+/* The presenter view has them in its toolbar (runtime/PresenterChrome.jsx). */
+deck-stage[data-presenter] :is(.poll-control, .poll-reset) { display: none; }
 /* Closed: no more answers count. */
 .poll-closed { padding: 2px 12px; border-radius: 999px; background: color-mix(in srgb, var(--ink, #111) 10%, transparent); color: var(--ink, #111); font-weight: 600; }
 /* results="hidden" or the eye off: the presenter's screens show the results faint and hatched, the audience none. */

package/src/core/editDeck.js

@@ -4,7 +4,8 @@
 // identical; callers reparse the result.
 import { parseSlides, SLIDE_KEYS, DECK_KEYS } from './parseSlides.js'
 import { applySourceEdits, replaceRegion, normalizeBlock, detectNewline, patchYamlMapping, firstYamlKey } from './source.js'
-import { openTagsIn } from './tags.js'
+import { openTagsIn, tagsIn, closingTagOf } from './tags.js'
+import { planFor, formatTime } from './timing.js'
 
 const REGION_RE = /^[a-z][a-z0-9-]*$/
 
@@ -247,11 +248,27 @@ export function hasActivity(slide) {
 // to its id afterwards (an automatic `slide-N` moves up), `removed` the ids
 // that are gone, so saved drawings can follow their slides.
 export function stripActivities(source) {
+  return shareSlides(source, { activities: true })
+}
+
+// The slides a shared build keeps: those numbered in `slides` (1-based, as
+// written; null for all) and, with `activities`, none with a live activity.
+// A deck of nothing but activities keeps them rather than becoming empty. A
+// <style> on a slide left out styles the whole deck, so it moves to the
+// first kept slide. The deck's `time` becomes what the kept slides were
+// planned to take, so each keeps its share. Returns { source, ids, removed }
+// as stripActivities.
+export function shareSlides(source, { activities = false, slides = null } = {}) {
   const deck = parseSlides(source)
-  const dropped = deck.slides.filter(hasActivity)
   const same = () => ({ source, ids: Object.fromEntries(deck.slides.map(slide => [slide.id, slide.id])), removed: [] })
-  // A deck of nothing but activities stays as it is rather than becoming empty.
-  if (!dropped.length || dropped.length === deck.slides.length) return same()
+  if (slides) {
+    const beyond = slides.filter(n => n > deck.slides.length)
+    if (beyond.length) throw new Error(`The deck has ${deck.slides.length} slides; there is no slide ${beyond.join(', ')}`)
+  }
+  let chosen = deck.slides.filter((slide, i) => !slides || slides.includes(i + 1))
+  if (activities && !chosen.every(hasActivity)) chosen = chosen.filter(slide => !hasActivity(slide))
+  const dropped = deck.slides.filter(slide => !chosen.includes(slide))
+  if (!dropped.length) return same()
   const ranges = dropped.map(slide => {
     const bounds = slideBounds(deck, slide.id)
     const next = deck.slides[deck.slides.indexOf(slide) + 1]
@@ -266,8 +283,28 @@ export function stripActivities(source) {
     if (last && range.start <= last.end) last.end = Math.max(last.end, range.end)
     else merged.push({ ...range })
   }
-  const next = edit(deck, merged.map(range => ({ ...range, text: '', expected: expectedText(deck, range) })))
+  let next = edit(deck, merged.map(range => ({ ...range, text: '', expected: expectedText(deck, range) })))
+  const styles = dropped.flatMap(slide => styleBlocks(deck.source.slice(slide.source.start, slide.source.end)))
+  if (styles.length) {
+    const kept = parseSlides(next)
+    const nl = detectNewline(next)
+    next = appendBlock(kept, kept.slides[0], styles.join(nl) + nl)
+  }
+  if (deck.deckConfig.time != null) {
+    const plan = planFor(deck.slides, deck.deckConfig)
+    const kept = chosen.reduce((sum, slide) => sum + plan.perSlide[deck.slides.indexOf(slide)], 0)
+    if (plan.budget) next = setDeckConfig(parseSlides(next), { time: kept ? formatTime(kept) : undefined })
+  }
   const after = parseSlides(next).slides
-  const kept = deck.slides.filter(slide => !dropped.includes(slide))
-  return { source: next, ids: Object.fromEntries(kept.map((slide, i) => [slide.id, after[i]?.id ?? slide.id])), removed: dropped.map(slide => slide.id) }
+  return { source: next, ids: Object.fromEntries(chosen.map((slide, i) => [slide.id, after[i]?.id ?? slide.id])), removed: dropped.map(slide => slide.id) }
+}
+
+// The <style> elements in a slide's text, found as the slide finds them (not in code).
+function styleBlocks(text) {
+  const tags = tagsIn(text)
+  return tags.flatMap((tag, at) => {
+    if (tag.name !== 'style' || tag.closing || tag.start == null) return []
+    const close = closingTagOf(tags, at)
+    return close?.end != null ? [text.slice(tag.start, close.end)] : []
+  })
 }