@hypersocial/decks-cli 0.8.1 → 0.9.0

package/README.md

@@ -154,7 +154,9 @@ Hi, I'm Selçuk's mini avatar. [wave] This is Hyperdecks. [mood: excited]
   time of the word before it.
 - Voice tags (`[whispers]`, `[laughs]`, `[sighs]`, `[excited]`, …) are sent to the
   voice and left out of the captions.
-- Unknown tags, a tag with no word before it, and headings with no matching section
+- `[play]` / `[pause]` (the video cues, not `[pause: s]`) may open a line instead:
+  they fire at the start of that line's first word.
+- Unknown tags, any other tag with no word before it, and headings with no matching section
   fail with line numbers.
 
 `--dry-run` lists each slide, its hash and whether it would render. It renders nothing.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hypersocial/decks-cli",
-  "version": "0.8.1",
+  "version": "0.9.0",
   "description": "Command-line client for Hypersocial Decks live analytics and share management.",
   "type": "module",
   "main": "./src/commands.mjs",

package/skills/hyperdecks/SKILL.md

@@ -147,6 +147,7 @@ Hyperdecks server; use the CLI where you have a shell and the tool otherwise.
 | One more link | `hyperdecks share new <slug> "<name>" [--no-forward]` | `create_share` (`allowForward`) |
 | Forwarding, one link | `hyperdecks share forward on\|off\|default <token>` | `set_share_forwarding` |
 | Forwarding, whole deck | `hyperdecks deck forward on\|off <slug>` | `set_deck_forwarding` |
+| Slides or scroll, viewer toggle | `hyperdecks deck view <slug> [slides\|scroll\|default] [--toggle on\|off]` | `set_deck_view` |
 | Who watched | `hyperdecks deck stats <slug>` | `deck_stats` |
 | All activity | `hyperdecks activity --deck <slug>` | `activity_overview` |
 | What one person watched | `hyperdecks engagement "<name>" --deck <slug> --json` | `recipient_engagement` |
@@ -159,6 +160,15 @@ Disabling the parent link (`share off`) turns off its forwards too, and
 `share forward default` (or `allowForward: null`) drops a link's own setting
 so it follows the deck's.
 
+How a deck opens (slides or scroll) is a deck setting too: `deck view <slug>
+scroll` (`set_deck_view { slug, view: "scroll" }`) takes effect on every link's
+next load, with no re-release; `default` (`view: null`) goes back to what the
+HTML says. Viewers get a slides/scroll toggle in the player, remembered per
+link, unless you turn it off (`--toggle off`, `viewToggle: false`). A viewer
+who already switched keeps their own choice while the toggle is on; turn the
+toggle off to make every viewer see the deck's view.
+`deck list --json` / `list_decks` and `deck stats` / `deck_stats` show both.
+
 ### 1. Ground it in the user's own material
 
 Build the deck from what you can already read in this session: files in the
@@ -197,13 +207,15 @@ Files, all in `decks/<slug>/`:
   keep the cues at the words they belong to.
 - `evidence.md`: the sources table. Private: release never uploads it.
 
-The deck contract (`check` enforces each line):
+The deck contract (`check` enforces or warns on each line):
 
 - One `<section class="slide" id="<id>">` per slide; ids are lowercase,
   unique, and in the same order as the `##` blocks in `script.md`.
 - Every slide has `data-note="<source of its facts>"`, e.g.
   `data-note="Q3 numbers: finance-update.pdf, 2026-10-02"`. A slide with no
-  facts says so: `data-note="Title slide: no facts."`.
+  facts says so: `data-note="Title slide: no facts."`. A missing note is a
+  warning, and an error on a pitch deck (`data-kind="pitch"` on the player
+  script: its claims need sources) or under `check --strict`.
 - A title (first `<h1>`/`<h2>`) over 28 characters carries
   `data-title-mobile="<shorter>"`. The scaffold puts one on every title.
 - Each slide keeps its `<div class="narration-slot"></div>` (where the
@@ -213,6 +225,24 @@ The deck contract (`check` enforces each line):
 - The player script stays
   `<script type="module" src="https://decks.hypersocial.ai/player/v1/player.js" data-manifest="…">`.
   `narrate` fills `data-manifest`; do not edit it by hand.
+- A deck with no narration (a product tour, an imported design deck, a silent
+  walkthrough) says so: `data-silent` on the player script. `check` then warns
+  "no narration (silent deck)" instead of failing, release skips narrate, and
+  the player shows the slides, arrows, tabs and scroll mode with no Play
+  button, clock or caption bubble. Without `data-silent` a missing
+  `data-manifest` still fails, so a forgotten narrate is caught.
+- The `<style data-hd-loading>` block in `<head>` is boilerplate the tools
+  write: `deck new` includes it, `check --fix` inserts or refreshes it, and a
+  hosted `write_deck_source` of index.html puts it right on the way in.
+- To read the deck as one long page instead of slide by slide, add
+  `data-view="scroll"` to that player script (on the hosted MCP, through
+  write_deck_source). The slides stay as they are: they stack and snap, the
+  page fades to each landed slide's background (`data-bg="#ffd166"` on a
+  `<section>` overrides it), the presenter travels to each slide's
+  `narration-slot` as you scroll, and the narration scrolls the page on by
+  itself. Remove the attribute to go back. For a released deck, prefer the
+  deck setting (`deck view <slug> scroll`, `set_deck_view`): it overrides the
+  attribute and needs no re-release.
 - Local images and files sit inside the deck folder and are referenced
   relatively (`img/chart.png`). Hosted images (`gen-image` URLs) are fine too.
 - A file the deck's own JavaScript loads (`fetch('media/data.json')`, a clip
@@ -238,6 +268,14 @@ its `##` heading.
 | `glass` | dark or busy slides: head and captions on one frosted panel |
 | `corner` | the slide is the point (a product shot, a chart, a demo): small head bottom-right, subtitles along the bottom |
 
+Size it per slide with `data-presenter-size="s|m|l|xl"` on the `<section>`
+(0.7×, 1×, 1.3×, 1.6× the style's head; on the player tag it is the deck's
+default): `xl` on a slide with empty space, `s` on a busy product slide. Phones
+keep `l`/`xl` at their usual size. A slide's CSS `--hd-presenter-scale: 1.15`
+fine-tunes it. `check` warns on an unknown size. In `corner`, `[look]` turns
+the head; `[go]` highlights the target and looks at it but the head stays in
+its corner.
+
 The live head's face follows script cues too (`[nod]`, `[look #card]`,
 `[smile]`, `[gesture: lightbulb]`; see the script topic); a still face ignores them.
 
@@ -283,12 +321,79 @@ Viewers can poke the live head: a click or tap makes it react (an "oof", a
 flinch) and a drag pulls it a little before it springs back, without pausing
 the narration.
 
+<!-- topic: scripts -->
+#### What your scripts can do
+
+A deck is a web page: its own `<script>`s run with the player, inline or from
+a file in the deck folder (release ships both; the player strips nothing).
+Put a module script after the player script tag, so `window.hyperdecks` is
+there. What your code can hook into:
+
+- **Controllers**: `window.hyperdecks.register("<slide-id>", { onEnter,
+  onExit, prebuild, onCue, onNarration })`. `onEnter(ctx)` / `onExit(ctx)`
+  run as the slide comes and goes, `prebuild(ctx)` during the hold before it
+  (load something heavy), `onCue(cue, ctx)` on each cue of the slide, and
+  `onNarration(state, ctx)` hears `playing`, `paused`, `ended` and `waiting`.
+  `ctx` is `{ id, index, slide, clip, position, presenter: { setMood, emote,
+  wave, go, look }, player: { show, next, prev, toggle, pause, resume } }`.
+  A classic script that runs before the player queues
+  `window.hyperdecks = [["<slide-id>", controller]]` instead.
+- **Custom cues**: `[custom: confetti]` in script.md fires at the word before
+  it and reaches that slide's `onCue` (and the window's `deck:cue` event), as
+  `cue.action === "custom:confetti"` (words after the name arrive in `cue.args`).
+- **Pausing the narrator**: `ctx.player.pause()` / `resume()`, or
+  `window.hyperdecks.pauseNarration()` / `resumeNarration()` from any script,
+  while something on the slide speaks. Resume undoes only your own pause.
+- **Taps**: a click on a slide toggles narration, except on links, buttons,
+  form controls, `[role=button]`, `canvas`, focusable elements, anything drawn
+  with `cursor: pointer`, and anything marked `data-hd-tap`.
+- **Interactive slides**: `data-interactive` on the `<section>`: the presenter
+  speaks its clip, then the deck waits (no timer) with a Continue button while
+  the viewer plays; taps and swipes inside the slide leave narration alone.
+
+One slide using all of it (`## demo` in script.md: `Tap the bell, and [custom:
+confetti] that's the whole trick.`):
+
+```html
+<section class="slide" id="demo" data-interactive data-note="Demo: no facts.">
+  <h2>Try it</h2>
+  <button class="bell" data-hd-tap>Ring the bell</button>
+  <div class="narration-slot"></div>
+</section>
+<script type="module">
+  window.hyperdecks.register("demo", {
+    onEnter(ctx) { ctx.slide.classList.remove("is-party"); },
+    onCue(cue, ctx) { if (cue.action === "custom:confetti") ctx.slide.classList.add("is-party"); },
+  });
+  document.querySelector("#demo .bell").addEventListener("click", () => {
+    window.hyperdecks.pauseNarration();
+    const bell = new Audio("media/bell.mp3");
+    bell.onended = () => window.hyperdecks.resumeNarration();
+    bell.play();
+  });
+</script>
+```
+
 <!-- topic: design -->
 ### Design: make it look good
 
 A narrated deck is only as convincing as it looks. Design before you write the
 narration, and check the result at both widths (step 6).
 
+#### Rules the check enforces
+
+These fail `check` (step 5): a title over 28 characters with no
+`data-title-mobile`; a layout placeholder left in (the hero's empty `.art`,
+the product's `.shot`, the chart's made-up `<svg>`); an unknown presenter
+style or transition, a second `fly`; on a pitch deck or with `--strict`, a
+slide with no `data-note`; and, with `--layout` and always at release, a
+slide that overflows a 390×844 phone.
+
+#### House style (preferences)
+
+Everything below is the owner's house style, not a rule: follow it by
+default, and depart from it when the brief asks for something else.
+
 **One idea per slide.** The title states the idea as a sentence a listener
 could repeat ("Narration renders in two minutes", not "Speed"). Everything
 else on the slide supports that sentence; if it needs a second idea, it is a
@@ -392,8 +497,9 @@ where there is room so slide changes move the presenter.
   One style per deck, described the same way every time (subject, medium,
   palette hexes, "no text"). `--model nano-banana-2.1` when the image must
   carry legible type.
-- Video: `gen-video` for a short loop behind a hero or a product moment, with
-  `[play: video]` at its word; never needed for a deck to work. A clip that
+- Video: `gen-video` for a short loop behind a hero or a product moment;
+  never needed for a deck to work. A `muted loop` video plays while its slide
+  is current, no cue needed; a `data-hd-manual` one waits for `[play]`. A clip that
   plays on repeat should be made with `--loop` (`loop: true`): it starts and
   ends on the same frame, so there is no jump at the seam. Give it `--image`
   to loop a still you already have; without one a keyframe is rendered first.
@@ -430,21 +536,6 @@ still.
 - No CSS animation on slides beyond `.reveal`; the player animates the slide
   change.
 
-**Review before release (required).** After `check` passes and the deck is
-imported, run `hyperdecks review <slug> --script decks/<slug>/script.md`
-(`review_deck`, then poll `check_review_job`). Act on every finding:
-
-- `fix`: change the slide or the script, re-import (or `release --qa`), and
-  review again until no `fix` is left. Do not release with a `fix` open.
-- `consider`: apply it when it serves the slide's one idea; otherwise note in
-  your reply to the user why you left it.
-- A finding you disagree with (a deliberate choice, a misread screenshot):
-  say so to the user with the reason instead of silently ignoring it.
-
-If review cannot run (no credits, the service is down), say so to the user and
-do the step 6 screenshot pass yourself as the reviewer: the same desktop and
-phone screenshots, the same `fix` bar.
-
 <!-- topic: script -->
 ### 3. Write slides and script
 
@@ -498,7 +589,7 @@ phone screenshots, the same `fix` bar.
 | `[mood: excited]` / `[emote: name]` | the head's mood or emote |
 | `[reveal: #id]` | adds `is-revealed` to `#id` (reset when the slide is left or replays); the live head glances at it unless a `[look]`/`[go]` is beside it |
 | `[pause: 0.5]` | a beat of silence (≤ 5 s) |
-| `[play: video]` / `[pause: video]` | play or pause the slide's video |
+| `[play]` / `[pause]` (or `[play: .sel]`) | play or pause every video on the slide (or the matches); may open a line, firing as its first word starts. Muted loops play on their own, so this is for `data-hd-manual` clips |
 | `[go: #step-2]` / `[go: slot]` | fly beside that item, grow it, fade the other items / back to the slot |
 | `[look: h2]` / `[look #card]` | look at the title / the card, then back |
 | `[look viewer]` / `[look away]` | look back at the viewer / glance aside |
@@ -513,6 +604,10 @@ phone screenshots, the same `fix` bar.
 - No `voice:` in the front matter means the user's first ready voice. If
   `hyperdecks voice list` shows none, ask the user to record one and run
   `voice clone` (it asks them for consent; never clone anyone else's voice).
+- Names speech-to-text spells another way fail narrate's transcript check
+  (step 4). Map what it heard to what you wrote with a `normalize:` entry in
+  the front matter, `heard=written`, comma-separated: a clip that says
+  "Minimoji" but is transcribed as "Moji" needs `normalize: moji=minimoji`.
 
 ### 4. Narrate and read the guard
 
@@ -529,16 +624,24 @@ reword the sentence (spell numbers and names the way they are said, or add a
 ### 5. Check
 
 ```bash
-hyperdecks check decks/<slug> [--forbid "Other Co,codename"] [--layout]
+hyperdecks check decks/<slug> [--forbid "Other Co,codename"] [--layout] [--strict] [--fix]
 ```
 
+`--strict` fails every slide with no `data-note`, as a pitch deck does.
+`--fix` writes what the tools can before checking: today, a missing or stale
+loading state (`<style data-hd-loading>`).
+
 `--layout` lays each slide out in Chromium (needs `hyperdecks preview setup`).
 At the stage size it warns, without failing, when a slide's presenter would
 overlap its title. On a 390×844 phone (the share player's 374×736 slide card)
 it fails any slide whose content overflows: the player never scrolls a slide.
+`release` (local or `--hosted`) always runs this layout check and refuses an
+overflowing slide; `check <slug> --hosted --layout` measures a hosted draft.
 
 `--forbid` lists phrases that must not reach this audience (another customer,
-an internal codename). Messages and what to do:
+an internal codename). It matches the page's text, alt text, titles and
+script.md, not URLs in attributes, so forbidding your own brand still passes
+with the player's `decks.hypersocial.ai` script tag. Messages and what to do:
 
 | Message starts with | Fix |
 |---|---|
@@ -557,10 +660,11 @@ an internal codename). Messages and what to do:
 | ⚠ `<file> builds file paths at runtime` | list each file as a quoted path (an object or array, in a script or a `.json` it fetches) and pick from it |
 | ⚠ `<file> loads files from computed values` | fine when every file it can load is also written out as a quoted path; otherwise list them so release ships them |
 | `player script must be` / `no player script` | restore the player/v1 script tag |
-| `the player script has no data-manifest` | run `narrate` |
-| `no loading state` | copy the template's `<style data-hd-loading>` block (and the preload lines above it) into `<head>`; set `--hd-ground` / `--hd-ground-ink` to the first slide's colours |
+| `the player script has no data-manifest` | run `narrate`; or, for a deck with no narration, add `data-silent` to the player script |
+| ⚠ `no narration (silent deck)` | fine for a deck meant to be silent; remove `data-silent` and narrate to give it a voice |
+| `no loading state` | `check --fix` writes it (a hosted draft gets it on its next write of index.html); set `--hd-ground` / `--hd-ground-ink` to the first slide's colours in `:root`, never inside the block (it is replaced from the template) |
 | `forbidden phrase` | remove it from the page, script or narration |
-| `slide <id>: needs a data-note` | add the source |
+| `slide <id>: needs a data-note` / ⚠ `no data-note` | add the source (required on a `data-kind="pitch"` deck and with `--strict`) |
 | `slide <id>: title … needs a data-title-mobile` | add a shorter title |
 | `slide <id>: the hero's art` / `the product screenshot` / `the chart … is still the layout's placeholder` | make the real file (`gen-image`, `screenshot <url>`, `chart <spec.json>`) and swap the element for the `<img>` the message names; or delete the hero's `<div class="art">` for no art |
 | `… presenter style "…" is not one of` | use stage, bubble, glass or corner |
@@ -574,6 +678,21 @@ an internal codename). Messages and what to do:
 | `slide <id>: its content runs …px past the slide on a 390×844 phone` | trim that slide on phones: smaller type, fewer items, or hide decoration in its `@media (max-width: 650px)` rules (an `#id` rule outranks them; restate it there) |
 | ⚠ `slide <id>: the … presenter would overlap the title` | move that slide's `.narration-slot`, pad the text away from it, or use `corner` |
 
+**Review before release (required).** After `check` passes and the deck is
+imported, run `hyperdecks review <slug> --script decks/<slug>/script.md`
+(`review_deck`, then poll `check_review_job`). Act on every finding:
+
+- `fix`: change the slide or the script, re-import (or `release --qa`), and
+  review again until no `fix` is left. Do not release with a `fix` open.
+- `consider`: apply it when it serves the slide's one idea; otherwise note in
+  your reply to the user why you left it.
+- A finding you disagree with (a deliberate choice, a misread screenshot):
+  say so to the user with the reason instead of silently ignoring it.
+
+If review cannot run (no credits, the service is down), say so to the user and
+do the step 6 screenshot pass yourself as the reviewer: the same desktop and
+phone screenshots, the same `fix` bar.
+
 ### 6. Look at it, at both widths
 
 To watch it as it will really play, run `hyperdecks play decks/<slug>`. It plays
@@ -590,7 +709,7 @@ and screenshot it with Playwright at 1440×900 and 390×844, every slide
 (`#scene=<id>`). Look at both: nothing clipped, the presenter and its captions
 clear of the text, the mobile titles in use. Fix and repeat until both read well.
 
-Then the required review (see **Design**, *Review before release*): once the
+Then the required review (see **5. Check**, *Review before release*): once the
 deck is imported, `hyperdecks review <slug> --script decks/<slug>/script.md`
 (`review_deck`, then `check_review_job`) has GPT-6 Luna look at every slide of
 the deck's QA link on desktop and phone and list each problem as `fix` or

package/skills/hyperdecks/chat.md

@@ -4,7 +4,7 @@ You are building a narrated deck through the Hyperdecks connector: no terminal,
 no git, no folder. The deck's files (`index.html`, `script.md`, `evidence.md`)
 live on Hyperdecks as a draft; you read and edit them with tools, and nothing
 reaches a recipient until `release_deck`. Topics: call `deck_guide` with
-`format`, `script`, `design`, `layouts`, `presenter`, `transitions` or `check`
+`format`, `script`, `scripts`, `design`, `layouts`, `presenter`, `transitions` or `check`
 before the step that needs it.
 
 ## First time here?
@@ -90,7 +90,9 @@ makes the hello deck; continue from step 5 below.
 10. Later: `list_shares` and `deck_stats` (both show the card),
    `activity_overview`; `email_embed { token }` for the HTML that pastes into an
    email as the deck's moving preview (it needs a recipient's link, not a QA
-   one); `set_share_notify` to mute a link's "opened" alerts;
+   one); `set_deck_view { slug, view: "scroll" | "slides" | null, viewToggle }`
+   for how the deck opens and whether viewers may switch (every link, next
+   load, no re-release); `set_share_notify` to mute a link's "opened" alerts;
    `set_recipient_archived` to tidy the activity feed; `credits` for the
    balance. `remove_deck` deletes a deck and breaks every link to it: confirm
    with the user first.
@@ -98,9 +100,16 @@ makes the hello deck; continue from step 5 below.
 ## Rules that matter
 
 - Every slide is `<section class="slide" id="…" data-note="<source of its facts>">`,
-  in the same order as the `## <id>` blocks in `script.md`.
-- Keep the player script tag and the `<style data-hd-loading>` block the
-  scaffold wrote; never write `data-manifest` yourself.
+  in the same order as the `## <id>` blocks in `script.md`. A missing note
+  warns; on a pitch deck (`data-kind="pitch"` on the player script) it fails.
+- Keep the player script tag; never write `data-manifest` yourself. The
+  `<style data-hd-loading>` block is written for you on each write of index.html.
+- A deck with no narration (a product tour, a silent walkthrough): put
+  `data-silent` on the player script and skip narrate_deck; check warns, release
+  goes through, and the player shows no Play button or clock.
+- The deck's own scripts run: slide controllers, `[custom: name]` cues,
+  pausing the narrator, tappable and interactive slides. `deck_guide
+  { topic: "scripts" }` has the hooks and an example.
 - Edit the draft freely: recipients keep seeing the last release until you call
   `release_deck` again. A release is refused when the check fails, when
   narration is stale (narrate again first), when the draft changed after

package/src/check.mjs

@@ -1,4 +1,4 @@
-// hyperdecks check <slug|deck-dir> [--forbid "<phrase>,<phrase>"] [--max-duration <s>] [--layout] [--json]
+// hyperdecks check <slug|deck-dir> [--forbid "<phrase>,<phrase>"] [--max-duration <s>] [--layout] [--strict] [--fix] [--json]
 //
 // The narrated-deck integrity gate, ported from the Netflix presentation's
 // scripts/check.mjs and its variant builders. Every rule returns its message from
@@ -8,11 +8,14 @@
 // every clip's audio and timeline. `fetch` and `exists` are injectable for tests.
 // The rules themselves live in checkRules.mjs (no Node imports, shared with the
 // hosted check); this file adds the folder I/O and the Chromium measurements.
-import { existsSync, lstatSync, readFileSync, realpathSync } from "node:fs";
+import { existsSync, lstatSync, readFileSync, realpathSync, writeFileSync } from "node:fs";
 import { basename, isAbsolute, join, relative, resolve, sep } from "node:path";
 import { PHONE, PRESENTER_FOOTPRINT, checkSources, overlapWarnings, phoneOverflowErrors, slideStyles, stageSize, MESSAGES } from "./checkRules.mjs";
 
+import { withLoadingBlock } from "./loadingBlock.mjs";
+
 export * from "./checkRules.mjs";
+export * from "./loadingBlock.mjs";
 
 // Lay each slide out in Chromium at the deck's stage size with JavaScript off
 // (no player, no deck scripts), put the style's footprint in its slot, and
@@ -156,6 +159,27 @@ export function deckFolder(deckDir) {
   };
 }
 
+// The browser half of check --layout, on a folder holding the deck's index.html
+// (the hosted release measures a draft the same way, from a temp folder). A
+// presenter over the title is a warning, not a failure: only a person can judge
+// it. A slide that overflows the phone card is an error: the player never
+// scrolls a slide. No Chromium is a warning, as each measurement is optional.
+export async function layoutCheck(deckDir, html, manifest = null, { measure = measureLayout, measureFit = measurePhoneFit } = {}) {
+  const errors = [], warnings = [];
+  const { width: w, height: h } = stageSize(html);
+  try {
+    warnings.push(...overlapWarnings(await measure(deckDir, slideStyles(html, manifest), { width: w, height: h }), `${w}×${h}`));
+  } catch (e) {
+    warnings.push(MESSAGES.layoutUnchecked(e.message));
+  }
+  try {
+    errors.push(...phoneOverflowErrors(await measureFit(deckDir)));
+  } catch (e) {
+    warnings.push(MESSAGES.layoutUnchecked(e.message));
+  }
+  return { errors, warnings: [...new Set(warnings)] };
+}
+
 // Run every rule on a deck folder. Returns { deckDir, slug, slides, totalDuration, errors }.
 export async function checkDeck(dirArg, opts = {}, { fetch: fetchImpl = globalThis.fetch, cwd, measure = measureLayout, measureFit = measurePhoneFit } = {}) {
   const deckDir = resolveDeckDir(dirArg, cwd);
@@ -164,22 +188,11 @@ export async function checkDeck(dirArg, opts = {}, { fetch: fetchImpl = globalTh
   const script = existsSync(scriptPath) ? readFileSync(scriptPath, "utf8") : "";
   const { manifest, ...result } = await checkSources({ html, script }, { ...opts, hosted: false, exists: deckFileResolver(deckDir), ...deckFolder(deckDir) }, { fetch: fetchImpl });
   const { errors, warnings } = result;
-  // A presenter over the title is a warning, not a failure: only a person can
-  // judge it. A slide that overflows the phone card is an error. Both need a
-  // browser, so they run only with --layout.
+  // Both need a browser, so they run only with --layout (release always asks).
   if (opts.layout) {
-    const { width: w, height: h } = stageSize(html);
-    try {
-      warnings.push(...overlapWarnings(await measure(deckDir, slideStyles(html, manifest), { width: w, height: h }), `${w}×${h}`));
-    } catch (e) {
-      warnings.push(MESSAGES.layoutUnchecked(e.message));
-    }
-    // A slide that scrolls on a phone fails: the player never scrolls a slide.
-    try {
-      errors.push(...phoneOverflowErrors(await measureFit(deckDir)));
-    } catch (e) {
-      warnings.push(MESSAGES.layoutUnchecked(e.message));
-    }
+    const layout = await layoutCheck(deckDir, html, manifest, { measure, measureFit });
+    errors.push(...layout.errors);
+    warnings.push(...layout.warnings);
   }
   return {
     deckDir,
@@ -190,8 +203,21 @@ export async function checkDeck(dirArg, opts = {}, { fetch: fetchImpl = globalTh
   };
 }
 
+// --fix: what the tools can write for the deck, before the check reads it. Today
+// that is the loading state (a missing or stale <style data-hd-loading>).
+export function fixDeck(dirArg, { cwd } = {}) {
+  const deckDir = resolveDeckDir(dirArg, cwd);
+  const path = join(deckDir, "index.html");
+  const { html, fixed, skipped } = withLoadingBlock(readFileSync(path, "utf8"));
+  if (fixed) writeFileSync(path, html);
+  if (skipped) return [`index.html: not fixed: ${skipped}`];
+  return fixed ? [`index.html: ${fixed} the loading state (<style data-hd-loading>) from the template`] : [];
+}
+
 export async function check(pos, opts = {}, { log = (line) => console.log(line), ...io } = {}) {
-  const result = await checkDeck(pos[0], opts, io);
+  const fixed = opts.fix ? fixDeck(pos[0], io) : [];
+  if (!opts.json) for (const f of fixed) log(f.includes(": not fixed:") ? `⚠ ${f}` : `✓ fixed ${f}`);
+  const result = { ...(await checkDeck(pos[0], opts, io)), ...(opts.fix ? { fixed } : {}) };
   if (!opts.json) {
     log(`deck "${result.slug}": ${result.slides} slides${result.totalDuration != null ? `, ${result.totalDuration}s narrated` : ""}`);
     if (result.errors.length) {

package/src/checkRules.mjs

@@ -12,6 +12,8 @@ export const CAPTION_MIN_CHARS = 4;
 export const CAPTION_MAX_CHARS = 85;
 // Same names as PRESENTER_STYLES in lib/deckManifest.ts (the published CLI cannot import it).
 export const PRESENTER_STYLES = ["stage", "bubble", "glass", "corner"];
+// Same steps as PRESENTER_SIZES in packages/player/presenter-moves.js.
+export const PRESENTER_SIZES = ["s", "m", "l", "xl"];
 // Same names as TRANSITIONS in lib/deckManifest.ts and packages/player/transitions.js.
 export const TRANSITIONS = ["drift", "cut", "push", "wipe", "zoom", "morph", "fly"];
 export const MAX_TRANSITION_KINDS = 2;
@@ -19,11 +21,14 @@ export const MAX_TRANSITION_KINDS = 2;
 export const MESSAGES = {
   noPlayer: () => `no player script: add <script type="module" src="${PLAYER_V1}" data-manifest="…">`,
   player: (src) => `player script must be ${PLAYER_V1} (got ${src})`,
-  noManifest: () => "the player script has no data-manifest: run `hyperdecks narrate <deck-dir>`, which sets it",
-  noManifestHosted: () => "the player script has no data-manifest: call narrate_deck (no script) and wait for check_narration_job; it sets it",
+  noManifest: () => "the player script has no data-manifest: run `hyperdecks narrate <deck-dir>`, which sets it (or, for a deck with no narration, add data-silent to the player script)",
+  noManifestHosted: () => "the player script has no data-manifest: call narrate_deck (no script) and wait for check_narration_job; it sets it (or, for a deck with no narration, add data-silent to the player script)",
+  // Warnings: a deck that declared it has no narration.
+  silent: () => "no narration (silent deck): data-silent on the player script, so it plays with no voice, Play button or clock; to narrate it, remove data-silent and run `hyperdecks narrate`",
+  silentHosted: () => "no narration (silent deck): data-silent on the player script, so it plays with no voice, Play button or clock; to narrate it, remove data-silent and call narrate_deck",
   manifestUnavailable: (url, why) => `manifest ${url} could not be read (${why})`,
   noSlides: () => 'no slides: each slide is a <section class="slide" id="…">',
-  noLoading: () => "no loading state: copy the <style data-hd-loading> block and the lines above it from the narrated template into <head>, and set --hd-ground to the first slide's colour",
+  noLoading: () => "no loading state: run `hyperdecks check <deck> --fix` (`check <slug> --hosted --fix`; over the MCP, write index.html again with write_deck_source), which needs a <head>…</head> and the player script; or copy the <style data-hd-loading> block and the lines above it from the narrated template into <head>; set --hd-ground to the first slide's colour",
   clipField: (id, field) => `clip ${id}: ${field}`,
   noCaptions: (id) => `clip ${id}: timeline has no captions`,
   order: (slides, clips) => `slide ids (${slides.join(", ")}) must equal the manifest clip ids (${clips.join(", ")}), in order`,
@@ -42,11 +47,14 @@ export const MESSAGES = {
   scriptComputed: (from, calls) => `${from} loads files from computed values (${calls.join(", ")}); release only ships files the deck names literally, so make sure each file it can load is written out as a quoted path in index.html, a script or a .json file the deck loads`,
   forbidden: (phrase, where) => `forbidden phrase "${phrase}" appears in ${where}`,
   note: (id) => `slide ${id}: needs a data-note naming the source of its facts`,
+  // The same rule as a warning: required only on a pitch deck (data-kind="pitch") or with check --strict.
+  noteSoft: (id) => `slide ${id}: no data-note naming the source of its facts (required on a pitch deck, data-kind="pitch", and by check --strict)`,
   mobileTitle: (id, title) => `slide ${id}: title "${title}" is over ${MOBILE_TITLE_CHARS} characters and needs a data-title-mobile`,
   slideId: (n) => `slide ${n} has no id`,
   selector: (line, cue, selector, id) => `script.md line ${line}: [${cue}: ${selector}] matches nothing in slide ${id}`,
   gestureColon: (line, id) => `script.md line ${line}: [gesture ${id}] needs a colon: [gesture: ${id}]`,
   gesture: (line, id) => `script.md line ${line}: [gesture: ${id}] is not one of the head's gestures: ${GESTURES.join(", ")}`,
+  presenterSize: (where, value) => `${where}: data-presenter-size "${value}" is not one of ${PRESENTER_SIZES.join(", ")}; the presenter keeps its default size`,
   presenterStyle: (where, value) => `${where}: presenter style "${value}" is not one of ${PRESENTER_STYLES.join(", ")}`,
   transition: (where, value) => `${where}: transition "${value}" is not one of ${TRANSITIONS.join(", ")} (zoom takes a selector: "zoom #row")`,
   zoomTarget: (id, target, prev) => `slide ${id}: zoom target "${target}" matches nothing on the slide before it (${prev})`,
@@ -71,11 +79,14 @@ export const PHONE = { width: 390, height: 844, card: { width: 374, height: 736
 
 const uncommented = (html) => html.replace(/<!--[\s\S]*?-->/g, "");
 const attr = (tag, name) => {
-  const m = new RegExp(`\\s${name}\\s*=\\s*(?:"([^"]*)"|'([^']*)')`).exec(tag);
-  return m ? (m[1] ?? m[2]) : null;
+  const m = new RegExp(`\\s${name}\\s*=\\s*(?:"([^"]*)"|'([^']*)'|([^\\s"'=<>\`]+))`).exec(tag);
+  return m ? (m[1] ?? m[2] ?? m[3]) : null;
 };
 const round = (n) => Math.round(n * 100) / 100;
 const decode = (s) => s.replace(/&nbsp;/g, " ").replace(/&amp;/g, "&").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/&#39;|&apos;/g, "'");
+// Blank every attribute value that is an absolute or protocol-relative URL
+// (src, href, data-manifest, …); the audience never reads those.
+const withoutUrlAttrs = (html) => html.replace(/(\s[\w:.-]+\s*=\s*)(?:"(?:https?:)?\/\/[^"]*"|'(?:https?:)?\/\/[^']*')/gi, '$1""');
 const textOf = (html) => decode(html.replace(/<[^>]+>/g, " ")).replace(/\s+/g, " ").trim();
 
 // Comments blanked but newlines kept, so line numbers still match the file.
@@ -100,6 +111,15 @@ export function presenterStyleErrors(html, script = "") {
   return errs;
 }
 
+// Unknown presenter sizes (data-presenter-size on a slide or the player tag), with
+// their line: a warning, since the player falls back to the default size.
+export function presenterSizeWarnings(html) {
+  const page = blankComments(html);
+  return [...page.matchAll(/\sdata-presenter-size\s*=\s*(?:"([^"]*)"|'([^']*)')/g)]
+    .filter((m) => !PRESENTER_SIZES.includes((m[1] ?? m[2]).trim()))
+    .map((m) => MESSAGES.presenterSize(`index.html line ${lineAt(page, m.index)}`, m[1] ?? m[2]));
+}
+
 // "zoom #dash-row" → { name: "zoom", target: "#dash-row" }; null when it is not a transition.
 export function parseTransition(value) {
   if (typeof value !== "string") return null;
@@ -279,11 +299,26 @@ export function slides(html) {
   });
 }
 
+// The player tag also carries the deck's declarations: data-silent (no
+// narration, on purpose) and data-kind="pitch" (every slide sources its facts).
+// The check reads what the deck says, never guesses from its content.
+const hasAttr = (tag, name) => new RegExp(`\\s${name}(?=[\\s=>/])`).test(tag);
 export function playerScript(html) {
   const tag = [...uncommented(html).matchAll(/<script\b[^>]*>/g)].map((m) => m[0]).find((t) => /\/player\/v\d+\/player\.js"/.test(t));
-  return tag ? { src: attr(tag, "src"), manifest: attr(tag, "data-manifest") || null } : null;
+  if (!tag) return null;
+  return {
+    src: attr(tag, "src"),
+    manifest: attr(tag, "data-manifest") || null,
+    silent: hasAttr(tag, "data-silent") && !/^(false|0|no)$/i.test(attr(tag, "data-silent") ?? ""),
+    kind: attr(tag, "data-kind")?.trim().toLowerCase() || null,
+  };
 }
 
+// Source notes are required on a pitch deck (its claims) and under check
+// --strict; elsewhere a missing one is a warning.
+export const notesRequired = (html, { strict = false } = {}) => !!strict || playerScript(html)?.kind === "pitch";
+export const slidesWithoutNotes = (html) => slides(html).map((s, i) => (attr(s.tag, "data-note")?.trim() ? null : s.id || `${i + 1}`)).filter(Boolean);
+
 // Relative references: src, href, poster, data-presenter-image and data-alpha-stacked (either quote), srcset candidates and
 // CSS url(…) in style attributes and <style> blocks; everything that is not a URL
 // scheme, protocol-relative or a fragment. Query strings and fragments dropped.
@@ -504,7 +539,7 @@ export function placeholderErrors(html, { hosted = false } = {}) {
 
 // Everything checkable from the deck's own files. `exists(ref)` answers whether a
 // local reference resolves inside the deck folder: true, false or "outside".
-export function htmlErrors(html, { exists = () => true, forbid = [], script = "", hosted = false } = {}) {
+export function htmlErrors(html, { exists = () => true, forbid = [], script = "", hosted = false, strict = false } = {}) {
   const errs = [...presenterStyleErrors(html, script), ...transitionErrors(html, script), ...cueSelectorErrors(html, script), ...cueGestureErrors(script), ...placeholderErrors(html, { hosted })];
   const player = playerScript(html);
   if (!player) errs.push(MESSAGES.noPlayer());
@@ -515,10 +550,11 @@ export function htmlErrors(html, { exists = () => true, forbid = [], script = ""
   if (player && !loading?.[1].includes("hd-fail-open")) errs.push(MESSAGES.noLoading());
   const all = slides(html);
   if (!all.length) errs.push(MESSAGES.noSlides());
+  const notes = notesRequired(html, { strict });
   all.forEach((s, i) => {
     const id = s.id || `${i + 1}`;
     if (!s.id) errs.push(MESSAGES.slideId(i + 1));
-    if (!attr(s.tag, "data-note")?.trim()) errs.push(MESSAGES.note(id));
+    if (notes && !attr(s.tag, "data-note")?.trim()) errs.push(MESSAGES.note(id));
     if (s.title.length > MOBILE_TITLE_CHARS && !attr(s.titleTag, "data-title-mobile") && !attr(s.tag, "data-title-mobile")) {
       errs.push(MESSAGES.mobileTitle(id, s.title));
     }
@@ -530,9 +566,13 @@ export function htmlErrors(html, { exists = () => true, forbid = [], script = ""
     else if (!found) errs.push(MESSAGES.localRef(ref));
   }
   const page = textOf(uncommented(html).replace(/<(script|style)\b[\s\S]*?<\/\1>/g, " ")).toLowerCase();
+  // The raw HTML too (alt text, <title>, meta content, inline script), less
+  // attribute values that are URLs: the player's own src (PLAYER_V1) names
+  // decks.hypersocial.ai, so forbidding the brand would otherwise always fail.
+  const raw = withoutUrlAttrs(uncommented(html)).toLowerCase();
   for (const phrase of phraseList(forbid)) {
     const p = phrase.toLowerCase();
-    if (page.includes(p) || uncommented(html).toLowerCase().includes(p)) errs.push(MESSAGES.forbidden(phrase, "index.html"));
+    if (page.includes(p) || raw.includes(p)) errs.push(MESSAGES.forbidden(phrase, "index.html"));
     if (script.toLowerCase().includes(p)) errs.push(MESSAGES.forbidden(phrase, "script.md"));
   }
   return errs;
@@ -708,7 +748,9 @@ const isHostedAsset = (url) => {
 // resolves (true, false or "outside"); `hosted: true` means there is no folder,
 // so every local reference is an error naming upload_deck_asset, a hotlinked
 // image is a warning, and the layout rules (which need Chromium) are reported as
-// not checked. Returns { slides, totalDuration, manifestUrl, manifest, passed, errors, warnings }.
+// not checked. `strict: true` makes every slide's data-note an error, as on a
+// pitch deck. Returns { slides, totalDuration, manifestUrl, manifest, silent,
+// passed, errors, warnings }; `silent` is a deck with no manifest that declared data-silent.
 export async function checkSources({ html, script = "" }, opts = {}, { fetch: fetchImpl = globalThis.fetch } = {}) {
   const forbid = phraseList(opts.forbid);
   const flagCap = opts["max-duration"] ?? opts.maxDuration;
@@ -717,14 +759,22 @@ export async function checkSources({ html, script = "" }, opts = {}, { fetch: fe
     throw new Error(flagCap !== undefined ? "--max-duration needs a number of seconds" : "maxTotalSeconds in script.md must be a number of seconds");
   }
   const exists = opts.hosted ? () => "hosted" : (opts.exists ?? (() => true));
-  const errors = htmlErrors(html, { exists, forbid, script, hosted: !!opts.hosted });
+  const strict = !!opts.strict;
+  const errors = htmlErrors(html, { exists, forbid, script, hosted: !!opts.hosted, strict });
+  const warnings = [];
+  if (!notesRequired(html, { strict })) for (const id of slidesWithoutNotes(html)) warnings.push(MESSAGES.noteSoft(id));
   // Without a folder (hosted, or a caller that passes no reader) only the inline scripts are read.
   const walked = deckFiles(html, opts.hosted ? {} : { pathExists: opts.pathExists, read: opts.read, isDir: opts.isDir });
   for (const m of walked.missing) errors.push(MESSAGES.scriptRef(m.ref, m.from));
   const ids = slides(html).map((s) => s.id);
   const player = playerScript(html);
   let manifest = null;
-  if (player && !player.manifest) errors.push(opts.hosted ? MESSAGES.noManifestHosted() : MESSAGES.noManifest());
+  // A deck that declares itself silent plays without narration; without the
+  // declaration a missing manifest is still a forgotten narrate. Slides with
+  // data-clip audio are narrated (the player plays them), so not silent.
+  const silent = !!player && !player.manifest && player.silent && !slides(html).some((s) => attr(s.tag, "data-clip"));
+  if (silent) warnings.push(opts.hosted ? MESSAGES.silentHosted() : MESSAGES.silent());
+  else if (player && !player.manifest) errors.push(opts.hosted ? MESSAGES.noManifestHosted() : MESSAGES.noManifest());
   if (player?.manifest) {
     const got = await fetchCheck(fetchImpl, player.manifest, JSON_TYPE);
     if (got.why) errors.push(MESSAGES.manifestUnavailable(player.manifest, got.why));
@@ -775,7 +825,7 @@ export async function checkSources({ html, script = "" }, opts = {}, { fetch: fe
       errors.push(...timelineErrors(clip, timeline));
     }
   }
-  const warnings = transitionWarnings(html, script, manifest);
+  warnings.push(...transitionWarnings(html, script, manifest), ...presenterSizeWarnings(html));
   for (const t of walked.templates) warnings.push(MESSAGES.scriptTemplate(t.from, t.samples));
   for (const c of walked.computed) warnings.push(MESSAGES.scriptComputed(c.from, c.calls));
   if (opts.hosted) {
@@ -787,6 +837,7 @@ export async function checkSources({ html, script = "" }, opts = {}, { fetch: fe
     totalDuration: manifest ? Number(manifest.totalDuration) : null,
     manifestUrl: player?.manifest ?? null,
     manifest,
+    silent,
     passed: errors.length === 0,
     errors,
     warnings: [...new Set(warnings)],

package/src/commands.mjs

@@ -58,6 +58,7 @@ async function deckStats(pos, opts) {
   console.log(`  unique viewers: ${s.viewers}`);
   console.log(`  avg engaged:    ${fmtMs(s.avgMs)}`);
   console.log(`  total engaged:  ${fmtMs(s.totalMs)}`);
+  if (s.view !== undefined) console.log(`  plays as:       ${s.view ?? "as its HTML says"}${s.viewToggle === false ? " (viewer toggle off)" : ""}${s.usesPlayer === false ? " (won't apply: the deck doesn't load player/v1)" : ""}`);
   if (s.recent?.length) {
     console.log("  recent:");
     for (const r of s.recent) {
@@ -153,6 +154,31 @@ async function deckForward(pos, opts) {
   console.log(`OK forwarding ${mode} for deck ${slug} (links with their own setting keep it)`);
 }
 
+const VIEW_USAGE = "usage: deck view <slug> [slides|scroll|default] [--toggle on|off]";
+const VIEWS = { slides: "slides", scroll: "scroll", default: null };
+async function deckView(pos, opts) {
+  const [slug, mode] = pos;
+  const toggle = opts.toggle;
+  if (!slug || (mode === undefined && !Object.hasOwn(opts, "toggle"))) throw new Error(VIEW_USAGE);
+  if (mode !== undefined && !Object.hasOwn(VIEWS, mode)) throw new Error(VIEW_USAGE);
+  // A trailing --toggle with no value is a mistake, not "leave it".
+  if (Object.hasOwn(opts, "toggle") && toggle !== "on" && toggle !== "off") throw new Error(VIEW_USAGE);
+  const out = await ops.setDeckView(opts, slug, {
+    view: mode === undefined ? undefined : VIEWS[mode],
+    viewToggle: toggle === undefined ? undefined : toggle === "on",
+  });
+  if (opts.json) return void console.log(JSON.stringify(out, null, 2));
+  const said = [];
+  if (mode !== undefined) said.push(mode === "default" ? "opens as its HTML says" : `opens as ${mode}`);
+  if (toggle !== undefined) said.push(`viewer toggle ${toggle}`);
+  if (out.applies === false) {
+    console.log(`OK deck ${slug} ${said.join(", ")} (saved)`);
+    console.warn(`warning: ${out.warning}`);
+    return;
+  }
+  console.log(`OK deck ${slug} ${said.join(", ")} (every link, on its next load)`);
+}
+
 function shareUrl(pos, opts) {
   const [token] = pos;
   if (!token) throw new Error("usage: share url <token>");
@@ -264,6 +290,7 @@ async function importDeck(pos, opts) {
     console.log(`  html:   ${(out.bytes / 1024).toFixed(1)} KB`);
     console.log(`  deck:   ${out.deckUrl}`);
   }
+  for (const w of out.warnings ?? []) console.warn(`warning: ${w}`);
 }
 
 async function importDesignDeck(pos, opts) {
@@ -304,23 +331,28 @@ commands:
   login [--token <pat>] [--broker <url>] [--dev]
   logout [--dev]
   whoami [--json] [--dev]
-  deck list|stats|open|rm|forward
+  deck list|stats|open|rm|forward|view
   deck forward on|off <slug>
                    whether viewers can forward the deck's links (on by default; a link's own setting wins)
+  deck view <slug> [slides|scroll|default] [--toggle on|off]
+                   how the deck opens in the player (default: as its HTML says, data-view or slides) and
+                   whether viewers get the slides/scroll toggle (on by default). Every link, next load; no re-release.
   deck new <slug> "<title>" --narrated [--layouts hero,product,number,closer] [--presenter-style stage|bubble|glass|corner] [--no-brand] [--dir <path>]
                    scaffold decks/<slug>/: index.html (8 slides, or one per layout, player/v1), script.md, evidence.md,
                    in your saved brand's colours, fonts and logo (--no-brand: the template's look)
                    layouts: hero, number, product, quote, compare, timeline, features, chart, team, closer
-  check <slug|deck-dir> [--forbid "<phrase>,<phrase>"] [--max-duration <s>] [--layout] [--json]
+  check <slug|deck-dir> [--forbid "<phrase>,<phrase>"] [--max-duration <s>] [--layout] [--strict] [--fix] [--json]
                    the narrated-deck gate: slides vs manifest, timing, captions, clip URLs,
-                   local refs, pinned player, a data-note per slide, mobile titles
+                   local refs, pinned player, mobile titles. data-silent on the player script: no narration
+                   (a warning). Missing data-notes warn, and fail on a data-kind="pitch" deck or with --strict.
+                   --fix writes what the tools can (a missing or stale loading state) before checking
   deck new|check|release … --hosted
                    the same on a hosted draft (no folder, no git: what chat agents use over the remote MCP)
   source pull <slug> [dir] | source push <slug> [dir] [--base-rev N]
                    move a hosted draft (index.html, script.md, evidence.md) to a folder and back
   asset add <slug> <file|url> [--name n]
                    file an image, video or font under the deck; prints its hosted URL
-  guide [workflow|format|script|design|layouts|presenter|transitions|check]
+  guide [workflow|format|script|scripts|design|layouts|presenter|transitions|check]
                    the skill, one topic at a time (what deck_guide serves)
   play <slug|deck-dir> [--voice <the voice it was narrated in>] [--slug <slug>] [--port <n>] [--no-open] [--json]
                    play the folder as it is, committed or not, with its real face and voice, on 127.0.0.1
@@ -676,9 +708,10 @@ function commandTable(pos, rest, opts) {
     },
     check: async () => {
       const { check } = await import("./check.mjs");
-      const { hostedCheck } = await import("./source.mjs");
-      const result = opts.hosted ? await hostedCheck(opts, { slug: pos[1], forbid: opts.forbid, maxDuration: opts["max-duration"] }) : await check(pos.slice(1), opts);
+      const { hostedCheckCli } = await import("./source.mjs");
+      const result = opts.hosted ? await hostedCheckCli(opts, { slug: pos[1], forbid: opts.forbid, maxDuration: opts["max-duration"], strict: opts.strict, fix: opts.fix }) : await check(pos.slice(1), opts);
       if (opts.hosted && !opts.json) {
+        for (const f of result.fixed ?? []) console.log(f.includes(": not fixed:") ? `⚠ ${f}` : `✓ fixed ${f}`);
         console.log(`deck "${pos[1]}" rev ${result.rev}: ${result.slides} slides${result.totalDuration != null ? `, ${result.totalDuration}s narrated` : ""}`);
         for (const e of result.errors) console.log(`  - ${e}`);
         if (!result.errors.length) console.log("✓ check passed");
@@ -689,8 +722,8 @@ function commandTable(pos, rest, opts) {
     },
     release: async () => {
       if (opts.hosted) {
-        const { hostedRelease } = await import("./source.mjs");
-        const out = await hostedRelease(opts, { slug: pos[1], recipients: opts.recipients, qa: opts.qa, title: opts.title, forbid: opts.forbid, captionsOnly: opts["captions-only"] });
+        const { hostedReleaseCli } = await import("./source.mjs");
+        const out = await hostedReleaseCli(opts, { slug: pos[1], recipients: opts.recipients, qa: opts.qa, title: opts.title, forbid: opts.forbid, captionsOnly: opts["captions-only"] }, opts.json ? { log: (line) => console.error(line) } : {});
         if (opts.json) return void console.log(JSON.stringify(out, null, 2));
         console.log(`✓ released ${out.slug} rev ${out.rev}\n  deck: ${out.deckUrl}`);
         const who = presenterLine(out.presenter);
@@ -849,6 +882,7 @@ function commandTable(pos, rest, opts) {
     "deck open": () => deckOpen(rest, opts),
     "deck rm": () => deckRemove(rest, opts),
     "deck forward": () => deckForward(rest, opts),
+    "deck view": () => deckView(rest, opts),
     "share new": () => shareNew(rest, opts),
     "share list": () => shareList(rest, opts),
     "share on": () => shareToggle(rest, opts, true),

package/src/deckPlayer.mjs

@@ -0,0 +1,45 @@
+// Whether a deck runs on the Hyperdecks player (player/v1). One rule, shared by
+// Convex (decks.usesPlayer), the share route (owner chip vs fallback pill), the
+// importers and the CLI, so they never disagree. Scroll mode, the viewer
+// slides/scroll toggle and the owner chip all live in player/v1; a deck that
+// runs its own runtime (a legacy copy-and-swap deck.js, a plain HTML export)
+// gets none of them.
+
+export const loadsPlayer = (html) => /\/player\/v1\/player\.js\b/.test(String(html ?? ""));
+
+const SCRIPT_SRC = /<script\b[^>]*\ssrc\s*=\s*(?:"([^"]*)"|'([^']*)'|([^\s>]+))[^>]*>/gi;
+const MAX_SCRIPT_NAME = 120;
+
+// The deck's own entry script, for the warning ("it runs deck.js"): its first
+// module script, else its first script with a src. Only the file name, so
+// https://cdn.example/js/deck.js reads as deck.js. Null when
+// the deck loads player/v1, has no script with a src, or its script is an
+// uploaded asset (a storage URL names no file).
+export function ownScript(html) {
+  const doc = String(html ?? "").replace(/<!--[\s\S]*?-->/g, "");
+  if (loadsPlayer(doc)) return null;
+  const tags = [...doc.matchAll(SCRIPT_SRC)].map((m) => ({ tag: m[0], src: (m[1] ?? m[2] ?? m[3] ?? "").trim() })).filter((s) => s.src);
+  const pick = tags.find((s) => /\stype\s*=\s*["']?module\b/i.test(s.tag)) ?? tags[0];
+  // An imported asset's src is a storage URL (…/api/storage/<uuid>): no name to show.
+  if (!pick || /\/api\/storage\//.test(pick.src)) return null;
+  const name = pick.src.split(/[?#]/)[0].split("/").filter(Boolean).pop() || pick.src;
+  return name.slice(0, MAX_SCRIPT_NAME);
+}
+
+// What Convex stores on the deck row.
+export function deckPlayer(html) {
+  if (loadsPlayer(html)) return { usesPlayer: true, ownScript: undefined };
+  return { usesPlayer: false, ownScript: ownScript(html) ?? undefined };
+}
+
+const runs = (script) => (script ? ` (it runs its own ${script})` : "");
+
+// Import: a warning, never a refusal (plain HTML exports are legitimate decks).
+export const importPlayerWarning = (script) =>
+  `deck doesn't load player/v1${runs(script)}: scroll mode, the owner chip and the viewer toggle won't apply`;
+
+// set_deck_view / `deck view` on such a deck: the value is saved for a later
+// rebuild on player/v1, but does nothing today.
+export const viewPlayerWarning = (slug, script) =>
+  `${slug} doesn't load player/v1${runs(script)}, so slides/scroll and the viewer toggle won't apply. ` +
+  "The setting is saved and takes effect once the deck is rebuilt on player/v1 (deck_guide explains the format).";

package/src/guide.mjs

@@ -8,7 +8,7 @@ import { packageText } from "./files.mjs";
 import { LAYOUTS, readLayout } from "./layouts.mjs";
 import { fontPairingsMarkdown } from "./brand.mjs";
 
-export const GUIDE_TOPICS = ["workflow", "format", "script", "design", "layouts", "presenter", "transitions", "check"];
+export const GUIDE_TOPICS = ["workflow", "format", "script", "scripts", "design", "layouts", "presenter", "transitions", "check"];
 const CLI_NOTE = "_Written for the CLI. On the hosted MCP there is no folder: use the tool names in `deck_guide` (workflow), hosted URLs for every file, and write_deck_source for edits._\n\n";
 
 // One <!-- topic: name --> section of SKILL.md: its heading and body, up to the

package/src/hosted.mjs

@@ -61,10 +61,10 @@ export async function uploadDeckAsset(opts, { slug, name, url, file } = {}) {
   return (await client(opts)).action(api.assetsNode.importAssetFromUrl, { slug, name: assetName, url: String(from), ...(file?.mime_type ? { mimeType: String(file.mime_type) } : {}) });
 }
 
-export async function hostedCheck(opts, { slug, forbid, maxDuration } = {}) {
+export async function hostedCheck(opts, { slug, forbid, maxDuration, strict } = {}) {
   if (!slug) throw new Error("slug is required");
   const list = typeof forbid === "string" ? forbid.split(",").map((s) => s.trim()).filter(Boolean) : forbid;
-  return (await client(opts)).action(api.deckSources.check, { slug, ...(list?.length ? { forbid: list } : {}), ...(maxDuration ? { maxDuration: Number(maxDuration) } : {}) });
+  return (await client(opts)).action(api.deckSources.check, { slug, ...(list?.length ? { forbid: list } : {}), ...(maxDuration ? { maxDuration: Number(maxDuration) } : {}), ...(strict ? { strict: true } : {}) });
 }
 
 export async function hostedRelease(opts, { slug, recipients, qa, title, forbid, rev, voice, captionsOnly } = {}) {

package/src/loadingBlock.mjs

@@ -0,0 +1,72 @@
+// The loading state every player deck carries in <head> (check's noLoading):
+// the preloads, the frame flag and the <style data-hd-loading> block, exactly as
+// templates/narrated-deck.html and templates/layouts/_deck.html have it
+// (lib/loadingBlock.test.ts keeps the three in step). A JS string, not a read of
+// the template, because Convex (the hosted draft's write) cannot read package files.
+// No Node imports: the CLI and Convex (and so the MCP route's writes) use it.
+export const LOADING_BLOCK = [
+  "<!-- Loading state (keep verbatim; `hyperdecks check` requires it). Until the",
+  "     player marks body[data-hd-ready] the page shows only the slide card, at its",
+  "     final size, in the deck's --hd-ground (its first slide's colour) on the",
+  "     page's brand colour, with a quiet loader in --hd-ground-ink; then the",
+  "     slides fade in. If the player never arrives, the slides show after 10 s",
+  "     rather than never. Put data-layout=\"overlay\" on <html> for the overlay. -->",
+  "<link rel=\"modulepreload\" href=\"https://decks.hypersocial.ai/player/v1/player.js\">",
+  "<link rel=\"preload\" as=\"style\" href=\"https://decks.hypersocial.ai/player/v1/player.css\">",
+  "<script>if (self !== top || /[?&]thumb\\b/.test(location.search)) document.documentElement.dataset.hdFrame = \"\";</script>",
+  "<style data-hd-loading>",
+  "  body:not([data-hd-ready]) { overflow: hidden; background: var(--hd-frame, var(--hd-ground, var(--hd-accent, #ffda1b))); animation: hd-fail-open 0s 10s forwards; }",
+  "  body:not([data-hd-ready]) > * { visibility: hidden; animation: hd-fail-open 0s 10s forwards; }",
+  "  body[data-hd-ready] > * { animation: hd-in .2s ease-out; }",
+  "  body::before, body::after { content: \"\"; position: fixed; z-index: -1; pointer-events: none; transition: opacity .2s ease-out; }",
+  "  /* The card as the player draws it (player.css, framed): 16:9, scaled to fit",
+  "     between the 64px masthead and the 56px dock, 24px in from the sides. */",
+  "  body::before { inset: 64px 24px 56px; margin: auto; width: min(100vw - 48px, (100dvh - 120px) * 16 / 9); height: min(100dvh - 120px, (100vw - 48px) * 9 / 16); border-radius: calc(min(100vw - 48px, (100dvh - 120px) * 16 / 9) * .01125); background: var(--hd-ground, #fff); box-shadow: 0 0 0 1px color-mix(in srgb, var(--hd-ground-ink, #0b0b0f) 16%, transparent); }",
+  "  body::after { left: 50%; top: 50%; width: 12px; height: 12px; margin: -6px 0 0 -6px; border-radius: 50%; color: var(--hd-ground-ink, #0b0b0f); background: currentColor; box-shadow: -24px 0 currentColor, 24px 0 currentColor; opacity: 0; animation: hd-dots .7s ease-in-out .6s infinite alternate; }",
+  "  body[data-hd-ready]::before, body[data-hd-ready]::after { opacity: 0; animation: none; }",
+  "  /* The overlay (embedded, ?thumb, or data-layout=\"overlay\"): the stage fills the window. */",
+  "  :is([data-hd-frame], [data-layout=\"overlay\"]) body::before { inset: 0; width: min(100vw, 100dvh * 16 / 9); height: min(100dvh, 100vw * 9 / 16); border-radius: calc(min(100vw, 100dvh * 16 / 9) * .01125); box-shadow: none; }",
+  "  [data-layout=\"overlay\"] body:not([data-hd-ready]) { background: var(--hd-backdrop, #16161c); }",
+  "  [data-hd-frame] body:not([data-hd-ready]) { background: transparent; }",
+  "  [data-hd-frame] body::before { border-radius: 0; }",
+  "  /* Phones: the card fills the space between a 52px masthead and the dock, 8px in. */",
+  "  @media (max-width: 650px) {",
+  "    body::before { inset: 52px 8px calc(56px + env(safe-area-inset-bottom)); width: auto; height: auto; border-radius: 14px; }",
+  "    :is([data-hd-frame], [data-layout=\"overlay\"]) body::before { inset: 0; width: auto; height: auto; border-radius: 0; }",
+  "  }",
+  "  @media (prefers-reduced-motion: reduce) {",
+  "    body::before, body::after { transition: none; }",
+  "    body:not([data-hd-ready])::after { animation: none; opacity: .4; }",
+  "    body[data-hd-ready] > * { animation: none; }",
+  "  }",
+  "  @keyframes hd-in { from { opacity: 0; } }",
+  "  @keyframes hd-dots { from { opacity: .15; } to { opacity: .6; } }",
+  "  @keyframes hd-fail-open { to { visibility: visible; overflow: auto; } }",
+  "</style>",
+].join("\n");
+
+const STYLE = /<style\b[^>]*\sdata-hd-loading(?=[\s>=])[^>]*>[\s\S]*?<\/style>/i;
+const HEAD = /<head\b[^>]*>[\s\S]*?<\/head>/i;
+const PLAYER = /<script\b[^>]*\/player\/v\d+\/player\.js"[^>]*>/;
+const LOADING_STYLE = STYLE.exec(LOADING_BLOCK)[0];
+
+// The page with its loading state put right: inserted after <title> (or at the
+// top of <head>) when <head> has none, or its <style data-hd-loading> replaced
+// when it differs from the template's. Only a page with the player script, as
+// the check asks only those. Returns { html, fixed: "inserted" | "refreshed" | null,
+// skipped? }: a player page with no <head>…</head> is left alone, with `skipped` saying why.
+export function withLoadingBlock(html) {
+  const live = html.replace(/<!--[\s\S]*?-->/g, (c) => " ".repeat(c.length)); // same offsets, comments blanked
+  const head = HEAD.exec(live);
+  if (!PLAYER.test(live)) return { html, fixed: null };
+  if (!head) return { html, fixed: null, skipped: "no <head>…</head> to put the loading state in" };
+  const style = STYLE.exec(head[0]);
+  if (style) {
+    const at = head.index + style.index;
+    if (html.slice(at, at + style[0].length) === LOADING_STYLE) return { html, fixed: null };
+    return { html: html.slice(0, at) + LOADING_STYLE + html.slice(at + style[0].length), fixed: "refreshed" };
+  }
+  const title = /<\/title>/i.exec(head[0]);
+  const at = head.index + (title ? title.index + title[0].length : /^<head\b[^>]*>/i.exec(head[0])[0].length);
+  return { html: `${html.slice(0, at)}\n${LOADING_BLOCK}${html.slice(at)}`, fixed: "inserted" };
+}

package/src/ops.mjs

@@ -1,3 +1,4 @@
+import { deckPlayer, importPlayerWarning, viewPlayerWarning } from "./deckPlayer.mjs";
 import { zipSync } from "fflate";
 import { COLOR_KEYS, FONT_PAIRINGS, FONT_ROLES, findPairing, googleFontsUrl } from "./brand.mjs";
 import { MAX_IMPORT_FILE_BYTES, draftArgs, extractFile } from "./brandImport.mjs";
@@ -26,6 +27,12 @@ export async function listDecks(opts = {}) {
     status: d.status,
     ownerEmail: d.ownerEmail ?? null,
     hasHtml: !!(d.html || d.htmlStorageId || d.hasHtml),
+    // How it opens (null: as its HTML says) and whether viewers may switch.
+    view: d.view ?? null,
+    viewToggle: d.viewToggle !== false,
+    // false: the deck runs its own player, so view/viewToggle do not apply
+    // (null: not known yet, treated as on).
+    usesPlayer: d.usesPlayer ?? null,
   }));
 }
 
@@ -466,6 +473,32 @@ export async function setDeckForwarding(opts, slug, allowForward) {
   return { slug, allowForward: !!allowForward };
 }
 
+// How a deck opens in the player and whether viewers may switch: view is
+// "slides", "scroll", or null to follow the deck's own HTML again; viewToggle
+// true/false. Either may be left out; both go in one owner-only mutation, so a
+// failure changes neither.
+// Applies on every link's next load (the route injects it), with no re-release.
+export const DECK_VIEWS = ["slides", "scroll"];
+export async function setDeckView(opts, slug, { view, viewToggle } = {}) {
+  if (!slug) throw new Error("slug is required");
+  if (view === undefined && viewToggle === undefined) throw new Error("give a view (slides, scroll or default) and/or a viewToggle");
+  if (view !== undefined && view !== null && !DECK_VIEWS.includes(view)) throw new Error(`view must be slides, scroll or null (got ${JSON.stringify(view)})`);
+  const res = await (await client(opts)).mutation(api.decks.setViewSettings, {
+    slug,
+    ...(view !== undefined ? { view } : {}),
+    ...(viewToggle !== undefined ? { viewToggle: !!viewToggle } : {}),
+  });
+  // Saved either way; a deck on its own player says the setting won't apply.
+  const applies = res?.applies !== false;
+  return {
+    slug,
+    ...(view !== undefined ? { view } : {}),
+    ...(viewToggle !== undefined ? { viewToggle: !!viewToggle } : {}),
+    applies,
+    ...(applies ? {} : { warning: viewPlayerWarning(slug, res?.ownScript ?? null) }),
+  };
+}
+
 // Register a new deck (draft) you own. Refuses any slug that already exists:
 // upsert would otherwise reset your own live deck to a draft and rename it.
 export async function createDeck(opts, { slug, title }) {
@@ -614,12 +647,17 @@ export async function importDeckFromBytes(opts = {}, fields = {}, adapter = {})
     await c.mutation(api.decks.setHtmlStorage, { slug, storageId: htmlStorageId, bytes: htmlBytes.byteLength });
 
     const t = target(opts);
+    // A warning, never a refusal: plain HTML exports are legitimate decks.
+    // Read before the asset rewrite, while the script still has its own name.
+    const player = deckPlayer(parsed.html);
     return {
       slug,
       title,
       status,
       assets: parsed.assets.length,
       bytes: htmlBytes.byteLength,
+      usesPlayer: player.usesPlayer,
+      warnings: player.usesPlayer ? [] : [importPlayerWarning(player.ownScript)],
       deployment: t.name,
       // The owner-facing dashboard view (Preview / Stats / Share / Present), not
       // the raw /d/<slug> storage redirect.

package/src/release.mjs

@@ -6,7 +6,8 @@
 //   2. runs check (the same rules as `hyperdecks check`) and stops on any issue;
 //   3. runs narrate, which re-renders only changed slides. If that changes the
 //      deck folder (a new manifest URL in index.html), release stops and asks for
-//      a commit, then a second release goes through;
+//      a commit, then a second release goes through. A silent deck (data-silent
+//      on the player script, no manifest) skips narrate and gets no avatar attached;
 //   4. imports index.html plus the local files it references (nothing else in the
 //      folder: script.md, evidence.md and narration/ stay private);
 //   5. creates one share per --to (paired in order with --email) and prints the URLs.
@@ -76,23 +77,27 @@ export function recipients(opts) {
 }
 
 export async function release(pos, opts = {}, io = {}) {
-  const { log = (line) => console.log(line), changes = deckChanges, untracked = untrackedFiles, commit = deckCommit, narrate = runNarrate, fetch, cwd } = io;
+  const { log = (line) => console.log(line), changes = deckChanges, untracked = untrackedFiles, commit = deckCommit, narrate = runNarrate, fetch, cwd, measure, measureFit } = io;
   const deckDir = resolveDeckDir(pos[0], cwd);
   const to = recipients(opts);
 
   const dirty = changes(deckDir);
   if (dirty) throw new Error(`refusing to release: ${deckDir} has uncommitted changes\n${dirty}\ncommit them first so the release corresponds to a commit`);
 
-  const checked = await checkDeck(deckDir, opts, { fetch, cwd });
+  // Always with the layout check: a slide that overflows a phone must not ship
+  // (the hosted release runs the same measurement, hostedLayoutCheck in source.mjs).
+  const checked = await checkDeck(deckDir, { ...opts, layout: true }, { fetch, cwd, ...(measure ? { measure } : {}), ...(measureFit ? { measureFit } : {}) });
   const slug = opts.slug || checked.slug;
   if (!SLUG.test(slug)) throw new Error(`"${slug}" is not a deck slug (lowercase letters, digits, dashes): rename the folder or pass --slug`);
   if (checked.errors.length) throw new Error(`check failed for ${slug}:\n${checked.errors.map((e) => `  - ${e}`).join("\n")}`);
   const bundle = releaseBundle(deckDir);
   const loose = untracked(deckDir, bundle.files);
   if (loose.length) throw new Error(`refusing to release: git does not track ${loose.join(", ")} (ignored or never added); commit them so the release corresponds to a commit`);
-  log(`✓ check passed: ${checked.slides} slides, ${checked.totalDuration}s`);
+  log(`✓ check passed: ${checked.slides} slides, ${checked.silent ? "silent (no narration)" : `${checked.totalDuration}s`}`);
+  for (const w of checked.warnings) log(`  ⚠ ${w}`);
   for (const [from, paths] of Object.entries(bundle.added)) log(`  +${paths.length} file(s) referenced from ${from}: ${paths.join(", ")}`);
 
+  if (checked.silent) return publish({ opts, io: { log, commit }, deckDir, slug, to, checked, bundle, released: bundle, summary: null });
   // Cached slides cost nothing, so this only renders what changed since the commit.
   // Only the options narrate understands: an undefined --slide/--voice key would fail its flag check.
   const narrateOpts = { ...opts, slug };
@@ -116,6 +121,11 @@ export async function release(pos, opts = {}, io = {}) {
   if (presenter) log("✓ presented by your avatar");
   // A terminal user sees this before it ships, so the CLI warns rather than refuses.
   else if (job.presenter && !job.presenter.face) log(`⚠ releasing captions only: ${job.presenter.reason ?? "no face"}`);
+  return publish({ opts, io: { log, commit }, deckDir, slug, to, checked, bundle, released, summary: job.presenter ?? null });
+}
+
+// Import the checked bundle and make the links: the end of every release.
+async function publish({ opts, io: { log, commit }, deckDir, slug, to, checked, bundle, released, summary }) {
   const imported = await ops.importDeckFromBytes(opts, {
     slug,
     title: opts.title,
@@ -150,5 +160,5 @@ export async function release(pos, opts = {}, io = {}) {
     log(`✓ share for "${r.recipient}"${share.qa ? " (QA, untracked)" : ""} → ${share.url}`);
   }
   if (!shares.length) log(`  no --to given: \`hyperdecks share new ${imported.slug} "Me" --qa\` makes a link for your own viewing`);
-  return { slug: imported.slug, deckDir, commit: sha, deckUrl: imported.deckUrl, totalDuration: checked.totalDuration, presenter: job.presenter ?? null, files: bundle.files, shares };
+  return { slug: imported.slug, deckDir, commit: sha, deckUrl: imported.deckUrl, totalDuration: checked.totalDuration, silent: !!checked.silent, presenter: summary, files: bundle.files, shares };
 }

package/src/runtime.mjs

@@ -8,7 +8,7 @@ import { fileURLToPath } from "node:url";
 import { ConvexHttpClient } from "convex/browser";
 import { makeFunctionReference } from "convex/server";
 
-export const VERSION = "0.8.1";
+export const VERSION = "0.9.0";
 const UPLOAD_TIMEOUT_MS = 125_000;
 
 export const PROD = {
@@ -98,6 +98,9 @@ export const api = {
     listForViewer: makeFunctionReference("decks:listForViewer"),
     remove: makeFunctionReference("decks:remove"),
     setAllowForward: makeFunctionReference("decks:setAllowForward"),
+    setView: makeFunctionReference("decks:setView"),
+    setViewToggle: makeFunctionReference("decks:setViewToggle"),
+    setViewSettings: makeFunctionReference("decks:setViewSettings"),
     setHtmlStorage: makeFunctionReference("decks:setHtmlStorage"),
     upsert: makeFunctionReference("decks:upsert"),
     whoami: makeFunctionReference("decks:whoami"),
@@ -153,7 +156,7 @@ export const api = {
   },
 };
 
-const BOOL = new Set(["prod", "dev", "admin", "json", "require-email", "qa", "no-notify", "allow-forward", "no-forward", "help", "version", "all-agents", "global", "project", "transparent", "loop", "upload", "dry-run", "narrated", "layout", "full-page", "force", "hosted", "yes", "no-voice", "no-skill", "no-release", "no-open", "save-to-minimoji", "captions-only", "no-brand", "no-logo"]);
+const BOOL = new Set(["prod", "dev", "admin", "json", "require-email", "qa", "no-notify", "allow-forward", "no-forward", "help", "version", "all-agents", "global", "project", "transparent", "loop", "upload", "dry-run", "narrated", "layout", "strict", "fix", "full-page", "force", "hosted", "yes", "no-voice", "no-skill", "no-release", "no-open", "save-to-minimoji", "captions-only", "no-brand", "no-logo"]);
 // release's recipients, in order: each --to starts one, and an --email right
 // after it belongs to it (`--to A --email a --to B`). Collected as opts.recipients;
 // opts.email stays the last --email for the other commands (share new).

package/src/source.mjs

@@ -6,15 +6,75 @@
 //   hyperdecks check <slug> --hosted
 //   hyperdecks release <slug> --hosted [--to "<name>" [--email e]]... [--qa]
 //   hyperdecks asset add <slug> <file|url> [--name n]
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
 import { basename, extname, join, resolve } from "node:path";
 import { api, client, uploadBytes } from "./runtime.mjs";
-import { SOURCE_FILES, getDeckSource, uploadDeckAsset, writeDeckSource } from "./hosted.mjs";
+import { HOSTED_LAYOUT_WHY, MESSAGES } from "./checkRules.mjs";
+import { withLoadingBlock } from "./loadingBlock.mjs";
+import { SOURCE_FILES, getDeckSource, hostedCheck, hostedRelease, uploadDeckAsset, writeDeckSource } from "./hosted.mjs";
 
 export * from "./hosted.mjs";
 
 // ---- CLI ------------------------------------------------------------------
 
+// The browser half of check --layout for a hosted draft. The hosted check runs
+// in Convex and can't open a browser (HOSTED_LAYOUT_WHY), so the CLI measures
+// the draft's index.html here, from a temp folder, with check.mjs's Chromium
+// code. Returns the rev it measured, and { errors, warnings } as check --layout.
+export async function hostedLayoutCheck(opts, { slug } = {}, { measure, measureFit } = {}) {
+  if (!slug) throw new Error("slug is required");
+  const got = await getDeckSource(opts, { slug, file: "index.html" });
+  const html = got.files?.["index.html"];
+  if (typeof html !== "string") throw new Error(`hosted deck "${slug}" has no index.html`);
+  const { layoutCheck } = await import("./check.mjs");
+  const dir = mkdtempSync(join(tmpdir(), "hyperdecks-hosted-layout-"));
+  try {
+    writeFileSync(join(dir, "index.html"), html);
+    return { rev: got.rev, ...(await layoutCheck(dir, html, null, { ...(measure ? { measure } : {}), ...(measureFit ? { measureFit } : {}) })) };
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+}
+
+// check <slug> --hosted [--layout]: the hosted rules, plus the layout measured
+// here when --layout asks for it (in place of the hosted check's "layout not
+// checked" warning).
+// --fix first puts the draft's loading state right (as check --fix does a folder's).
+export async function hostedCheckCli(opts, args, io = {}) {
+  const fixed = args.fix ? await hostedFix(opts, args) : undefined;
+  const result = { ...(await hostedCheck(opts, args)), ...(fixed ? { fixed } : {}) };
+  if (!opts.layout) return result;
+  const layout = await hostedLayoutCheck(opts, args, io);
+  const errors = [...result.errors, ...layout.errors];
+  const unchecked = MESSAGES.layoutUnchecked(HOSTED_LAYOUT_WHY);
+  return { ...result, errors, passed: errors.length === 0, warnings: [...new Set([...result.warnings.filter((w) => w !== unchecked), ...layout.warnings])] };
+}
+
+async function hostedFix(opts, { slug } = {}) {
+  if (!slug) throw new Error("slug is required");
+  const got = await getDeckSource(opts, { slug, file: "index.html" });
+  const html = got.files?.["index.html"];
+  if (typeof html !== "string") throw new Error(`hosted deck "${slug}" has no index.html`);
+  // The CLI's copy of the block only decides whether to write; the draft's write
+  // puts it right with the server's copy, and what it reports is what was stored.
+  const { fixed, skipped } = withLoadingBlock(html);
+  if (skipped) return [`index.html: not fixed: ${skipped}`];
+  if (!fixed) return [];
+  const written = await writeDeckSource(opts, { slug, file: "index.html", content: html, baseRev: got.rev });
+  return written?.fixed ? [`index.html: ${written.fixed}`] : [];
+}
+
+// release <slug> --hosted: the same layout check the local release runs, then
+// the release pinned to the rev that was measured, so a later write can't slip
+// an unmeasured draft through. A slide that overflows a phone refuses it.
+export async function hostedReleaseCli(opts, args, { log = (line) => console.log(line), ...io } = {}) {
+  const layout = await hostedLayoutCheck(opts, args, io);
+  if (layout.errors.length) throw new Error(`check failed for ${args.slug}:\n${layout.errors.map((e) => `  - ${e}`).join("\n")}`);
+  for (const w of layout.warnings) log(`  ⚠ ${w}`);
+  return hostedRelease(opts, { ...args, rev: layout.rev });
+}
+
 export async function sourcePull(pos, opts = {}, { log = (line) => console.log(line), cwd = process.cwd() } = {}) {
   const [slug, dirArg] = pos;
   if (!slug) throw new Error("usage: source pull <slug> [dir]");
@@ -39,10 +99,15 @@ export async function sourcePush(pos, opts = {}, { log = (line) => console.log(l
   if (!files.includes("index.html")) throw new Error(`no index.html in ${dir}`);
   let baseRev = opts["base-rev"] !== undefined ? Number(opts["base-rev"]) : undefined;
   let rev;
+  const fixed = [];
   for (const file of files) {
-    ({ rev } = await writeDeckSource(opts, { slug, file, content: readFileSync(join(/*turbopackIgnore: true*/ dir, file), "utf8"), baseRev }));
+    let written;
+    ({ rev, ...written } = await writeDeckSource(opts, { slug, file, content: readFileSync(join(/*turbopackIgnore: true*/ dir, file), "utf8"), baseRev }));
+    // The draft's write may put index.html's loading state right: say so, so the folder isn't silently behind.
+    if (written.fixed) fixed.push(`${file}: ${written.fixed}`);
     baseRev = baseRev === undefined ? undefined : rev; // each write moves the rev
   }
+  for (const f of fixed) log(`✓ the draft fixed ${f}; \`hyperdecks source pull ${slug}\` to bring it into the folder`);
   log(`✓ pushed ${files.join(", ")} to ${slug}: rev ${rev}`);
   return { slug, rev, files };
 }