mdeck 3.1.0 → 3.3.0

package/src/cli/index.js

@@ -12,7 +12,7 @@ import { loadRegistry, manifestsOf, serializeRegistry } from '../extensions/disc
 import { BACKUP_DIR } from '../build/editorPlugin.js'
 import { createEditorServer, createDesignServer } from '../build/editorServer.js'
 import { homePlugin } from '../build/homePlugin.js'
-import { checkDeck } from '../build/check.js'
+import { checkDeck, bibliographyDiagnostics } from '../build/check.js'
 import { livePlugin, startLiveServer } from '../live/server.js'
 import { inkPlugin } from '../build/inkPlugin.js'
 import { createPairing, pairingPlugin } from '../build/pairing.js'
@@ -24,8 +24,8 @@ import { ManifestError, KINDS } from '../extensions/manifest.js'
 
 import { frameworkRoot } from '../paths.js'
 import { parseSlides } from '../core/parseSlides.js'
-import { stripNotes as stripNotesFrom } from '../core/editDeck.js'
-import { parseArgs, validateServerOrigin } from './args.js'
+import { stripNotes as stripNotesFrom, stripActivities as stripActivitiesFrom } from '../core/editDeck.js'
+import { parseArgs, parseSlideNumbers, validateServerOrigin } from './args.js'
 import { assertDrawings } from '../build/drawings.js'
 import { createRelayAccess } from '../build/relayAccess.js'
 import { sessionCode } from '../live/code.js'
@@ -178,12 +178,13 @@ async function runNewWizard() {
   }
 }
 
-async function copyLocalAssets(slidesPath, outDir, { stripNotes = false } = {}) {
+async function copyLocalAssets(slidesPath, outDir, { stripNotes = false, stripActivities = false } = {}) {
   const absSlides = resolve(slidesPath)
   const deckDir = dirname(absSlides)
   const absOutDir = resolve(outDir)
   const raw = readFileSync(absSlides, 'utf-8')
-  const markdown = stripNotes ? stripNotesFrom(raw) : raw
+  let markdown = stripNotes ? stripNotesFrom(raw) : raw
+  if (stripActivities) markdown = stripActivitiesFrom(markdown).source
 
   for (const ref of collectLocalAssetRefs(markdown)) {
     const source = resolve(deckDir, ref)
@@ -320,12 +321,13 @@ const HELP = `
 
   ${c.dim}Make something to hand out${c.reset}
     ${c.green}mdeck build${c.reset} [slides.md] [-o dir/index.html]   A folder to host
-      --reader               reader view, notes removed unless --notes
+      --reader               reader view, notes removed unless --notes, polls kept as a record unless --no-polls
       --single-file          everything inlined into one file instead
       --launchers            add macOS/Linux and Windows launchers (folders only)
     ${c.green}mdeck send${c.reset} [slides.md] [-o talk.html]     One file to send: the reader view, speaker notes removed,
                                               with a PDF inside
       --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
     ${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
@@ -334,6 +336,11 @@ const HELP = `
   ${c.dim}Check and look things up${c.reset}
     ${c.green}mdeck migrate${c.reset} [slides.md] [--dry-run]   Update settings, local layouts and drawings to API 2.0
     ${c.green}mdeck check${c.reset} [slides.md] [--strict]        Validate source and local assets
+      --render               also show every slide in Chrome, all steps revealed: content that
+                             does not fit, text cut off or hard to read, errors on the page
+    ${c.green}mdeck snapshot${c.reset} [slides.md]                Pictures of slides as PNG files (default: .mdeck-snapshots/)
+      --slide <numbers>      only these slides: 3, 3,5 or 2-4
+      --dark | --light       in this appearance instead of the deck's own   -o <folder>
     ${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
@@ -463,11 +470,29 @@ if (command === 'new') {
   const input = requireInput('check')
   const registry = registryFor(input)
   const { diagnostics } = checkDeck(input, registry)
+  diagnostics.push(...await bibliographyDiagnostics(input))
+  if (hasFlag('--render') && !diagnostics.some(d => d.severity === 'error')) {
+    tip('Building the deck and looking at every slide in Chrome…')
+    try {
+      const { renderCheck } = await import('../build/renderCheck.js')
+      diagnostics.push(...await renderCheck(input))
+    } catch (error) { diagnostics.push({ severity: 'error', code: 'render', message: error.message, line: 1 }) }
+  }
   if (diagnostics.length) console.log(formatDiagnostics(diagnostics, input))
   const warned = diagnostics.length || registry.warnings.length
   if (diagnostics.some(d => d.severity === 'error') || (warned && hasFlag('--strict'))) process.exitCode = 1
   else ok(`Checked ${input}${warned ? ' (with warnings)' : ''}`)
 
+} else if (command === 'snapshot') {
+  const input = requireInput('snapshot')
+  try {
+    const slides = parseSlideNumbers(parsed.options['--slide'] ?? '')
+    const outDir = resolve(outputOption() ?? resolve(dirname(resolve(input)), '.mdeck-snapshots'))
+    const appearance = hasFlag('--dark') ? 'dark' : hasFlag('--light') ? 'light' : ''
+    const { snapshot } = await import('../build/renderCheck.js')
+    for (const file of await snapshot(input, { slides, outDir, appearance })) console.log(relative(process.cwd(), file))
+  } catch (error) { err(error.message); process.exitCode = 1 }
+
 } else if (command === 'list') {
   const KIND_WORDS = { layouts: 'layout', themes: 'theme', palettes: 'palette' }
   const [first, ...others] = positionals()
@@ -578,7 +603,8 @@ if (command === 'new') {
   ok(`Launch page: ${c.cyan}${new URL('home.html', local).href}${c.reset}`)
   tip(`Presenter:   ${new URL('?view=presenter', local).href}`)
   tip(`Audience:    ${new URL('?view=audience', local).href}`)
-  if (exposed) for (const url of server.resolvedUrls.network) tip(`On a phone:  ${new URL('?view=reader', url).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}`)
   ok(`Watching ${c.cyan}${abs}${c.reset}`)
@@ -645,6 +671,8 @@ if (command === 'new') {
   const launchers = !sending && hasFlag('--launchers')
   const reader = sending || hasFlag('--reader')
   const stripNotes = reader && !hasFlag('--notes')
+  // 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')
 
   if (!hasFlag('--no-drawings')) { try { assertDrawings(input) } catch (error) { err(error.message); process.exit(1) } }
@@ -659,7 +687,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, ink: !hasFlag('--no-drawings'), deckLook: reader }), viteSingleFile()],
+      plugins: [preact(), slidesPlugin(resolve(input), { inlineImages: selfContained, inlineMedia: selfContained, embedFonts: selfContained, stripNotes, stripActivities, ink: !hasFlag('--no-drawings'), deckLook: reader }), viteSingleFile()],
       build: {
         outDir,
         emptyOutDir: !tempDir,
@@ -677,7 +705,7 @@ if (command === 'new') {
   await mkdir(finalOutDir, { recursive: true })
 
   if (!selfContained) {
-    await copyLocalAssets(input, finalOutDir, { stripNotes })
+    await copyLocalAssets(input, finalOutDir, { stripNotes, stripActivities })
     if (launchers) await writePresenterLaunchers(finalOutDir, htmlFilename)
   }
 
@@ -701,6 +729,7 @@ 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).')
   ok(`${sending ? 'Made' : 'Built'}: ${c.cyan}${htmlFile}${c.reset}${reader ? ' — opens in the reader view' : ''}${selfContained ? ' (single file)' : ' + local assets'}\n`)
 
 // ── skill ─────────────────────────────────────────────────────────────────────
@@ -730,7 +759,7 @@ if (command === 'new') {
   try {
     await build({
       ...baseConfig(input, { selfContained: true }),
-      plugins: [preact(), slidesPlugin(resolve(input), { inlineImages: true, inlineMedia: true, embedFonts: true, ink: !hasFlag('--no-drawings'), deckLook: true }), viteSingleFile()],
+      plugins: [preact(), slidesPlugin(resolve(input), { inlineImages: true, inlineMedia: true, embedFonts: true, stripActivities: hasFlag('--no-polls'), ink: !hasFlag('--no-drawings'), deckLook: true }), viteSingleFile()],
       build: { outDir: tempDir, emptyOutDir: true, target: 'esnext', assetsInlineLimit: 100 * 1024 * 1024 },
       logLevel: 'warn',
     })

package/src/cli/themes.js

@@ -25,11 +25,14 @@ const usage = kind => `search [words] | install <${kind}> | remove <${kind}> | u
 function looksOf(registry, catalogue) {
   const builtIn = new Set([...catalogue.themes, ...catalogue.palettes].filter(entry => entry.builtIn).map(entry => entry.id + (catalogue.themes.includes(entry) ? ':t' : ':p')))
   const palettes = manifestsOf(registry, 'palette')
+  // Each theme's icon for the gallery's list (see renderPreviews).
+  const icons = new Map(catalogue.themes.map(entry => [entry.id, entry.icon]))
   const colours = tokens => Object.fromEntries(['--bg', '--surface', '--ink', '--accent', '--accent-2'].map(key => [key, tokens?.[key] ?? null]))
   return {
     mdeck: VERSION,
     themes: Object.values(manifestsOf(registry, 'theme')).map(theme => ({ id: theme.id, title: theme.title, description: theme.description ?? '', builtIn: builtIn.has(theme.id + ':t'),
-      palette: theme.palette, appearance: theme.appearance ?? 'light', palettes: palettesFor(theme, palettes).map(p => p.id) })),
+      palette: theme.palette, appearance: theme.appearance ?? 'light', palettes: palettesFor(theme, palettes).map(p => p.id),
+      ...(icons.get(theme.id) ? { icon: icons.get(theme.id) } : {}) })),
     palettes: Object.values(palettes).map(palette => ({ id: palette.id, title: palette.title, description: palette.description ?? '', builtIn: builtIn.has(palette.id + ':p'),
       ...(palette.theme ? { theme: palette.theme } : {}), light: colours(palette.light), dark: colours(palette.dark) })),
   }
@@ -148,8 +151,11 @@ export async function runPackages({ kind, positionals, flag, output, ui: { ok, e
         ok(`Checked ${catalogue.themes.length} themes and ${catalogue.palettes.length} palettes, light and dark, on every kind of slide`)
       }
       // Themes on the title slide, palettes on the chapter slide (the third).
-      await renderPreviews(looks.map(look => ({ file: resolve(out, 'previews', `${look.key}.webp`), theme: look.theme, palette: look.palette ?? '', slide: look.palette ? 3 : 1 })), { extensions })
-      for (const entry of catalogue.themes) entry.preview = `previews/themes/${entry.id}.webp`
+      // Themes also get an icon of their title slide for lists; a palette's
+      // colours are its icon.
+      await renderPreviews(looks.map(look => ({ file: resolve(out, 'previews', `${look.key}.webp`), theme: look.theme, palette: look.palette ?? '', slide: look.palette ? 3 : 1,
+        ...(look.palette ? {} : { icon: resolve(out, 'previews', `${look.key}-icon.webp`) }) })), { extensions })
+      for (const entry of catalogue.themes) Object.assign(entry, { preview: `previews/themes/${entry.id}.webp`, icon: `previews/themes/${entry.id}-icon.webp` })
       for (const entry of catalogue.palettes) entry.preview = `previews/palettes/${entry.id}.webp`
       writeFileSync(resolve(out, 'catalogue.json'), JSON.stringify(catalogue, null, 2) + '\n')
       // For the repository's theme browser: the sample deck with every theme

package/src/components/Bibliography.jsx

@@ -0,0 +1,23 @@
+import { useEffect, useState } from 'preact/hooks'
+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" />.
+
+function slice(order, part) {
+  const match = String(part ?? '').match(/^\s*(\d+)\s*\/\s*(\d+)\s*$/)
+  if (!match) return order
+  const [index, count] = [Number(match[1]), Number(match[2])]
+  if (!count || index < 1 || index > count) return order
+  const size = Math.ceil(order.length / count)
+  return order.slice((index - 1) * size, index * size)
+}
+
+export default function Bibliography({ part }) {
+  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('')
+  return <div class="bibliography csl-bib-body" dangerouslySetInnerHTML={{ __html: html }} />
+}

package/src/components/Poll.jsx

@@ -3,6 +3,7 @@ import { useEffect, useRef, useState } from 'preact/hooks'
 import { useRoom, latestByDevice } from '../live/client.js'
 import { t } from '../core/labels.js'
 import { JoinCode, ActivityFooter, wantsQr } from './activity.jsx'
+import { Icon } from './Icon.jsx'
 import './poll.css'
 
 // <poll room="lunch" question="Where do we eat?" options="Mensa|Thai|Pizza" />
@@ -16,13 +17,20 @@ import './poll.css'
 // with a tick outlines its label, bar and count in green. Showing it is an
 // event on the stage (`pollreveal`, { room, shown }), which the ink bus
 // passes to the audience window and other devices.
+//
+// A button with an eye shows or hides the results (bars and counts), the
+// same way (`pollresults`, { room, shown }). `results="hidden"` starts with
+// them hidden, e.g. for peer instruction. Hidden, the audience window shows no
+// bars; the presenter's own screens show them faint, so the presenter can
+// still judge the votes.
 
 const choicesOf = options => String(options ?? '').split('|').map(option => option.trim()).filter(Boolean)
 
-export default function Poll({ room = 'poll', question = '', options = '', qr, answer = '' }) {
+export default function Poll({ room = 'poll', question = '', options = '', qr, answer = '', results = '' }) {
   const choices = choicesOf(options)
   const correct = choicesOf(answer).filter(choice => choices.includes(choice))
   const [shown, setShown] = useState(false)
+  const [resultsShown, setResultsShown] = useState(results !== 'hidden')
   const ref = useRef()
   const stage = () => ref.current?.closest('deck-stage')
   useEffect(() => {
@@ -32,18 +40,30 @@ export default function Poll({ room = 'poll', question = '', options = '', qr, a
     target.addEventListener('pollreveal', onReveal)
     return () => target.removeEventListener('pollreveal', onReveal)
   }, [room, correct.length])
+  useEffect(() => {
+    const target = stage()
+    if (!target) return
+    const onResults = event => { if (event.detail?.room === room) setResultsShown(!!event.detail.shown) }
+    target.addEventListener('pollresults', onResults)
+    return () => target.removeEventListener('pollresults', onResults)
+  }, [room])
   const toggle = () => {
     const next = !shown
     setShown(next)
     stage()?.dispatchEvent(new CustomEvent('pollreveal', { detail: { room, shown: next, local: true } }))
   }
+  const toggleResults = () => {
+    const next = !resultsShown
+    setResultsShown(next)
+    stage()?.dispatchEvent(new CustomEvent('pollresults', { detail: { room, shown: next, local: true } }))
+  }
   const live = useRoom(room)
   const votes = latestByDevice(live.messages).map(message => message.data?.value).filter(vote => choices.includes(vote))
   const counts = choices.map(choice => votes.filter(vote => vote === choice).length)
   const max = Math.max(1, ...counts)
   const code = wantsQr(qr)
   const still = live.offline && !votes.length
-  return <div class={`poll${shown ? ' is-solved' : ''}${still ? ' is-static' : ''}`} ref={ref}>
+  return <div class={`poll${shown ? ' is-solved' : ''}${still ? ' is-static' : ''}${resultsShown ? '' : ' is-results-hidden'}`} ref={ref}>
     <div class="poll-main">
       {question && <p class="poll-question">{question}</p>}
       <div class="poll-bars" role="list">
@@ -54,6 +74,9 @@ export default function Poll({ room = 'poll', question = '', options = '', qr, a
         </div>)}
       </div>
       <ActivityFooter count={votes.length} {...live}>
+        <button type="button" class={`poll-results${resultsShown ? '' : ' is-off'}`} title={t(resultsShown ? 'poll.hideResults' : 'poll.showResults')} aria-label={t(resultsShown ? 'poll.hideResults' : 'poll.showResults')} aria-pressed={!resultsShown} onClick={toggleResults}>
+          <Icon name={resultsShown ? 'eye' : 'eye-off'} size={24} class="poll-results-icon" />
+        </button>
         {correct.length > 0 && <button type="button" class={`poll-solve${shown ? ' is-on' : ''}`} title={t(shown ? 'poll.hideAnswer' : 'poll.showAnswer')} aria-label={t(shown ? 'poll.hideAnswer' : 'poll.showAnswer')} aria-pressed={shown} onClick={toggle}>
           <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>
         </button>}

package/src/components/QrCodeTag.jsx

@@ -1,6 +1,6 @@
 import { h } from 'preact'
 import QrCode from './QrCode.jsx'
-import { useJoinLink } from '../live/client.js'
+import { useJoinLink, useFollowLink } from '../live/client.js'
 import { JoinCode } from './activity.jsx'
 import { t } from '../core/labels.js'
 import './poll.css'
@@ -9,6 +9,7 @@ import './poll.css'
 // <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"`).
+// <qrcode follow />: the link for following the slides on a phone or laptop.
 
 function JoinQr({ size }) {
   const link = useJoinLink()
@@ -18,10 +19,18 @@ function JoinQr({ size }) {
   </div>
 }
 
+function FollowQr({ size }) {
+  const link = useFollowLink()
+  return <div class="poll-join-slide">
+    <JoinCode {...link} size={Number(size) || 420} label={t('follow.scan')} tryHere={t('follow.tryHere')} />
+  </div>
+}
+
 // A bare `join` attribute arrives as "", so only "false" and the like turn it off.
 const isOn = value => value != null && !/^(false|no|off|0)$/i.test(String(value))
 
-export default function QrCodeTag({ url, join, size }) {
+export default function QrCodeTag({ url, join, follow, size }) {
   if (isOn(join)) return <JoinQr size={size} />
+  if (isOn(follow)) return <FollowQr size={size} />
   return <QrCode url={url} size={size ?? '200'} />
 }

package/src/components/VideoPlayer.jsx

@@ -77,6 +77,22 @@ export default function VideoPlayer({ src, url, play = 'click', aspect, muted })
     return () => stage.removeEventListener('slidechange', onSlideChange)
   }, [play, url])
 
+  // Web video click mode: slides stay mounted, so a playing video would go on
+  // (with sound) on the next slide. Leaving the slide unloads the player;
+  // coming back shows it ready to play again.
+  useEffect(() => {
+    if (play !== 'click' || !url) return
+    const stage = document.querySelector('deck-stage')
+    if (!stage) return
+    const embedUrl = getEmbedUrl(url, false)
+    function onSlideChange(e) {
+      const active = e.detail.slide?.contains(containerRef.current)
+      setIframeSrc(current => active ? (current ?? embedUrl) : null)
+    }
+    stage.addEventListener('slidechange', onSlideChange)
+    return () => stage.removeEventListener('slidechange', onSlideChange)
+  }, [play, url])
+
   const fixedAspect = typeof aspect === 'string' && aspect.trim() !== ''
 
   return (

package/src/components/activity.jsx

@@ -12,9 +12,9 @@ export const shortLink = url => url.replace(/^https?:\/\//, '')
 export const wantsQr = qr => !/^(false|no|off|0)$/i.test(String(qr ?? 'true'))
 
 /** The join code with the short link, or how to make phones reach the server. */
-export function JoinCode({ room, joinUrl, localJoinUrl, known, offline, qr = true, size = 300, label = t('poll.scan') }) {
+export function JoinCode({ room, joinUrl, localJoinUrl, known, offline, qr = true, size = 300, label = t('poll.scan'), tryHere = t('poll.tryHere') }) {
   if (!qr || offline || (!known && !joinUrl)) return null
-  if (!joinUrl) return <p class="poll-join poll-join--local">{t('poll.unreachable', { command: <code>mdeck run --network</code>, setting: <code>server</code> })} <a href={localJoinUrl} target="_blank" rel="noopener">{t('poll.tryHere')}</a></p>
+  if (!joinUrl) return <p class="poll-join poll-join--local">{t('poll.unreachable', { command: <code>mdeck run --network</code>, setting: <code>server</code> })} <a href={localJoinUrl} target="_blank" rel="noopener">{tryHere}</a></p>
   return <a class="poll-join" href={joinUrl} target="_blank" rel="noopener" data-room={room}>
     <QrCode url={joinUrl} size={String(size)} />
     <span>{label}</span>

package/src/components/citation.css

@@ -0,0 +1,28 @@
+/* ── Citations and references (src/runtime/citations.js) ────────────────── */
+.citation { font-style: normal; }
+.citation-key--missing {
+  color: var(--accent);
+  text-decoration: underline wavy var(--accent);
+  text-underline-offset: 4px;
+}
+
+/* A slide's references sit with its footnotes, above the footer. */
+.slide-citations {
+  font-size: var(--fs-small);
+  color: var(--muted);
+  border-top: 1px solid var(--rule);
+  padding-top: 20px;
+  margin-top: auto;
+}
+.slide-footnotes + .slide-citations { margin-top: 0; border-top: 0; padding-top: 8px; }
+.slide-citations .csl-bib-body { display: flex; flex-direction: column; gap: 4px; }
+
+/* Entries hang; numeric styles put the number in a margin column. */
+.csl-entry { line-height: 1.4; padding-left: 1.5em; text-indent: -1.5em; overflow-wrap: anywhere; }
+.csl-entry:has(.csl-left-margin) { display: grid; grid-template-columns: auto 1fr; column-gap: 0.6em; padding-left: 0; text-indent: 0; }
+.csl-left-margin { color: var(--muted); font-variant-numeric: tabular-nums; }
+.csl-entry a { color: inherit; text-decoration: none; }
+
+/* <bibliography />: the reference list on its slide. */
+.bibliography { display: flex; flex-direction: column; gap: 0.6em; font-size: var(--fs-small); color: var(--ink-soft); }
+.bibliography-hint { color: var(--muted); font-style: italic; }

package/src/components/poll.css

@@ -18,6 +18,15 @@ deck-stage[data-follower] .poll-reset { display: none; }
 /* answer="…": the tick outlines the right answer's row (label, bar, count) in green. */
 .poll-solve { display: grid; place-items: center; width: 44px; height: 44px; margin-left: auto; padding: 0; border: 1px solid var(--rule, #ccc); border-radius: 50%; background: none; color: var(--muted, #666); cursor: pointer; opacity: .55; transition: opacity .2s, background .2s, color .2s; }
 .poll-reset + .poll-solve { margin-left: 0; }
+.poll-results { display: grid; place-items: center; width: 44px; height: 44px; margin-left: auto; padding: 0; border: 1px solid var(--rule, #ccc); border-radius: 50%; background: none; color: var(--muted, #666); cursor: pointer; opacity: .55; transition: opacity .2s, background .2s, color .2s; }
+.poll-reset + .poll-results, .poll-results + .poll-solve { margin-left: 0; }
+.poll-results:hover, .poll-results:focus-visible { opacity: 1; }
+.poll-results.is-off { opacity: 1; background: var(--muted, #666); border-color: var(--muted, #666); color: #fff; }
+deck-stage[data-follower] .poll-results { display: none; }
+/* results="hidden" or the eye off: the presenter's screens show the results faint and hatched, the audience none. */
+.poll.is-results-hidden .poll-fill { opacity: .35; background: repeating-linear-gradient(45deg, var(--accent, #0d9488) 0 8px, transparent 8px 14px); }
+.poll.is-results-hidden .poll-count { opacity: .35; }
+deck-stage[data-follower] .poll.is-results-hidden .poll-fill, deck-stage[data-follower] .poll.is-results-hidden .poll-count { visibility: hidden; }
 .poll-solve svg { width: 24px; height: 24px; }
 .poll-solve:hover, .poll-solve:focus-visible { opacity: 1; }
 .poll-solve.is-on { opacity: 1; background: var(--poll-correct, #16a34a); border-color: var(--poll-correct, #16a34a); color: #fff; }
@@ -67,15 +76,16 @@ deck-stage[data-follower] .poll-solve { display: none; }
 .poll-join-slide { display: flex; flex-direction: column; align-items: center; gap: 20px; width: 100%; }
 .poll-join-slide .poll-join { font-size: var(--fs-body, 32px); gap: 16px; padding: 24px 32px; }
 .poll-join-slide .poll-link { font-size: 28px; }
-@media print { .poll-reset, .poll-dot, .poll-solve { display: none; } .poll-fill, .scale-fill, .word { transition: none; animation: none; } .question-cards li { animation: none; } }
+@media print { .poll-reset, .poll-dot, .poll-solve, .poll-results { display: none; } .poll-fill, .scale-fill, .word { transition: none; animation: none; } .question-cards li { animation: none; } }
 
 /* A record of the talk (no room server: a PDF, a file sent to readers): the
    question and its options, without counts, the live dot or a join code. */
 .poll.is-static .poll-count, .poll.is-static .scale-count { visibility: hidden; }
+.poll.is-static .poll-results { display: none; }
 .poll .poll-static, .poll-join-slide .poll-static { margin: 36px 0 0; color: var(--muted, #666); font-style: italic; font-size: var(--fs-small, 24px); }
 .poll-join-slide .poll-static { margin: 0; font-size: var(--fs-body, 32px); }
 
 /* On paper the join code and the presenter's controls have no use. */
 @media print {
-  .poll-join, .poll-reset, .poll-solve, .poll-dot { display: none !important; }
+  .poll-join, .poll-reset, .poll-solve, .poll-dot, .poll-results { display: none !important; }
 }

package/src/core/citations.js

@@ -0,0 +1,108 @@
+import { sourceLines, fenceState } from './source.js'
+
+// Pandoc's citation syntax, shared by the build (which formats the deck's
+// citations with citeproc) and the runtime (which puts the formatted text in
+// place): `[@smith2020]`, `[see @smith2020, p. 12; @doe2019]`, `[-@smith2020]`
+// and narrative `@smith2020` (`Smith (2020)`), optionally `@smith2020 [p. 12]`.
+// A narrative `@key` counts only when `isKey` knows it, so e-mail addresses and
+// handles stay text. Fenced and inline code are left alone.
+
+const KEY = String.raw`[\w][\w:.#$%&+?<>~/-]*`
+// Not a link (`](`, `][ref]`); a footnote may follow (`[@a][^1]`).
+const NOT_LINK = String.raw`(?!\(|\[(?!\^))`
+const BRACKETED = new RegExp(String.raw`\[([^\[\]\n]*?-?@[\w][^\[\]\n]*?)\]${NOT_LINK}`, 'g')
+// The key starts a word: `[info@fhnw.ch]` is an address, not a citation.
+const ITEM = new RegExp(String.raw`^((?:.*?\s)?)(-?)@(${KEY})(.*)$`, 's')
+const NARRATIVE = new RegExp(String.raw`(?<![\w@\[\]\`])@(${KEY})(?:\s\[([^\[\]\n]+)\]${NOT_LINK})?`, 'g')
+
+// Locator terms readers write after a comma, mapped to CSL labels.
+const LOCATORS = [
+  [/^(pp?\.?|pages?|S\.|Seiten?)\s*/i, 'page'],
+  [/^(chaps?\.?|ch\.|chapters?|Kap\.)\s*/i, 'chapter'],
+  [/^(secs?\.?|sections?|§§?)\s*/i, 'section'],
+  [/^(figs?\.?|figures?|Abb\.)\s*/i, 'figure'],
+  [/^(vols?\.?|volumes?|Bd\.)\s*/i, 'volume'],
+  [/^(paras?\.?|paragraphs?|¶¶?)\s*/i, 'paragraph'],
+  [/^(nos?\.?|numbers?|Nr\.)\s*/i, 'issue'],
+  [/^(ll?\.|lines?)\s*/i, 'line'],
+  [/^(eqs?\.?|equations?)\s*/i, 'equation'],
+]
+
+// Keys end before trailing punctuation: `@smith2020.` cites `smith2020`.
+const trimKey = key => key.replace(/[:.#$%&+?<>~/-]+$/, '')
+
+// `, p. 12, emphasis added` → locator `12`, label `page`, suffix `, emphasis added`.
+export function parseLocator(text) {
+  const rest = text.replace(/^\s*,?\s*/, '')
+  if (!rest) return {}
+  for (const [pattern, label] of LOCATORS) {
+    const term = rest.match(pattern)
+    if (!term) continue
+    const value = rest.slice(term[0].length).match(/^[^\s,;]+(?:\s*[-–]\s*[^\s,;]+)?/)
+    if (value) return withSuffix({ label, locator: value[0] }, rest.slice(term[0].length + value[0].length))
+  }
+  const number = rest.match(/^\d[\w]*(?:\s*[-–]\s*\w+)?/)
+  if (number) return withSuffix({ label: 'page', locator: number[0] }, rest.slice(number[0].length))
+  return { suffix: text.trim() }
+}
+
+const withSuffix = (item, suffix) => suffix.trim() ? { ...item, suffix: suffix.trim() } : item
+
+function parseItem(part) {
+  const match = part.match(ITEM)
+  if (!match) return null
+  const id = trimKey(match[3])
+  const after = match[3].slice(id.length) + match[4]
+  const item = { id, ...parseLocator(after) }
+  if (match[1].trim()) item.prefix = match[1].trim()
+  if (match[2]) item.suppressAuthor = true
+  return item
+}
+
+// Ranges of `code` and link targets in a line, which hold no citations.
+function codeSpans(text) {
+  const spans = []
+  const pattern = /(`+)[\s\S]*?\1|\]\([^)\s]*(?:\s[^)]*)?\)/g
+  for (let match; (match = pattern.exec(text));) spans.push([match.index, match.index + match[0].length])
+  return spans
+}
+
+// Every citation in `markdown`, in order: `{ start, end, raw, items, narrative }`.
+// `raw` is the text as written, the key the build's formatted output is filed under.
+export function scanCitations(markdown, { isKey = () => true } = {}) {
+  const found = []
+  let fence = null
+  for (const line of sourceLines(markdown)) {
+    const before = fence
+    fence = fenceState(line.text, fence)
+    if (before || fence || !line.text.includes('@')) continue
+    const code = codeSpans(line.text)
+    const taken = []
+    const free = (start, end) => ![...code, ...taken].some(([a, b]) => start < b && end > a)
+    for (const match of line.text.matchAll(BRACKETED)) {
+      const end = match.index + match[0].length
+      // `[@key]: …` at the start of a line defines a link reference.
+      const definition = line.text[end] === ':' && !line.text.slice(0, match.index).trim()
+      if (line.text[match.index - 1] === '!' || definition || !free(match.index, end)) continue
+      const items = match[1].split(';').map(parseItem)
+      if (items.some(item => !item)) continue
+      taken.push([match.index, end])
+      found.push({ start: line.start + match.index, end: line.start + end, raw: match[0], items, narrative: false })
+    }
+    for (const match of line.text.matchAll(NARRATIVE)) {
+      const id = trimKey(match[1])
+      const keyEnd = match.index + 1 + id.length
+      const end = match[2] != null ? match.index + match[0].length : keyEnd
+      if (!isKey(id) || !free(match.index, end)) continue
+      taken.push([match.index, end])
+      const item = { id, ...(match[2] != null ? parseLocator(match[2]) : {}) }
+      found.push({ start: line.start + match.index, end: line.start + end, raw: line.text.slice(match.index, end), items: [item], narrative: true })
+    }
+  }
+  return found.sort((a, b) => a.start - b.start)
+}
+
+// The cited keys, each once, in order of first citation.
+export function citedKeys(clusters) {
+  return [...new Set(clusters.flatMap(cluster => cluster.items.map(item => item.id)))]
+}

package/src/core/editDeck.js

@@ -4,6 +4,7 @@
 // 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 { maskCode } from '../live/roomTag.js'
 
 const REGION_RE = /^[a-z][a-z0-9-]*$/
 
@@ -228,3 +229,45 @@ export function stripNotes(source) {
     .map(block => blockRemoval(deck, block)))
   return edit(deck, edits)
 }
+
+// The live activities, and the code to join them (<qrcode join />): a slide
+// with one of them is left out of shared builds. <qrcode follow /> and other
+// QR codes stay.
+const ACTIVITY_RE = /<(poll|question|wordcloud|scale)\b/i
+const JOIN_RE = /<qrcode\b[^>]*?\sjoin(?:\s*=\s*(?:"([^"]*)"|'([^']*)'|\{?([^\s/>}]*)\}?))?(?=[\s/>])/i
+const joins = text => { const m = JOIN_RE.exec(text); return !!m && !/^(false|no|off|0)$/i.test(m[1] ?? m[2] ?? m[3] ?? '') }
+export function hasActivity(slide) {
+  return [slide.content ?? '', ...Object.values(slide.regions ?? {}).map(region => region.content ?? '')]
+    .some(text => { const masked = maskCode(text); return ACTIVITY_RE.test(masked) || joins(masked) })
+}
+
+// Removes every slide with a live activity (<poll>, <question>, <wordcloud>,
+// <scale>) for shared builds: a reader cannot vote, and the results belong to
+// the talk. Returns { source, ids, removed }: `ids` maps each kept slide's id
+// 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) {
+  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()
+  const ranges = dropped.map(slide => {
+    const bounds = slideBounds(deck, slide.id)
+    const next = deck.slides[deck.slides.indexOf(slide) + 1]
+    return bounds.delimiterStart != null
+      ? { start: bounds.delimiterStart, end: bounds.end }
+      : { start: bounds.start, end: next ? next.source.start : deck.source.length }
+  }).sort((a, b) => a.start - b.start)
+  // Neighbouring slides can share a delimiter: join ranges that touch.
+  const merged = []
+  for (const range of ranges) {
+    const last = merged.at(-1)
+    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) })))
+  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) }
+}

package/src/core/ink.js

@@ -188,6 +188,22 @@ export const inkPaint = color => PEN_PAINT[color] ?? color
 /** Strokes in drawing order: highlighter below the pen, as on paper. */
 export const inkOrder = strokes => [...strokes.filter(s => s.tool === 'highlighter'), ...strokes.filter(s => s.tool !== 'highlighter')]
 
+/**
+ * The end of a straight line from `from` to `to`, turned onto the nearest
+ * multiple of `step` degrees when it lies within `tolerance` of it (0°, 15°,
+ * 30° … by default); its length stays. Further off, the end stays as drawn.
+ */
+export function snapAngle([x0, y0], [x, y], { step = 15, tolerance = 4 } = {}) {
+  const dx = x - x0, dy = y - y0
+  const length = Math.hypot(dx, dy)
+  if (!length) return [x, y]
+  const angle = Math.atan2(dy, dx) * 180 / Math.PI
+  const snapped = Math.round(angle / step) * step
+  if (Math.abs(angle - snapped) > tolerance) return [x, y]
+  const rad = snapped * Math.PI / 180
+  return [Math.round((x0 + Math.cos(rad) * length) * 10) / 10, Math.round((y0 + Math.sin(rad) * length) * 10) / 10]
+}
+
 /** The stroke moved by dx, dy design pixels; the same id, so it replaces the original. */
 export const translateStroke = (stroke, dx, dy) => ({ ...stroke, points: stroke.points.map(([x, y, p]) => [x + dx, y + dy, p]) })