@hypersocial/decks-cli 0.8.1 → 0.8.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hypersocial/decks-cli",
-  "version": "0.8.1",
+  "version": "0.8.2",
   "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
@@ -213,6 +223,15 @@ 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.
+- 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
@@ -513,6 +532,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
 
@@ -536,9 +559,13 @@ hyperdecks check decks/<slug> [--forbid "Other Co,codename"] [--layout]
 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 |
 |---|---|

package/skills/hyperdecks/chat.md

@@ -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.

package/src/check.mjs

@@ -156,6 +156,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 +185,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,

package/src/checkRules.mjs

@@ -76,6 +76,9 @@ const attr = (tag, name) => {
 };
 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.
@@ -530,9 +533,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;

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,9 +331,12 @@ 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)
@@ -676,8 +706,8 @@ 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"] }) : await check(pos.slice(1), opts);
       if (opts.hosted && !opts.json) {
         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}`);
@@ -689,8 +719,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 +879,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/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

@@ -76,14 +76,16 @@ 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")}`);
@@ -91,6 +93,7 @@ export async function release(pos, opts = {}, io = {}) {
   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`);
+  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(", ")}`);
 
   // Cached slides cost nothing, so this only renders what changed since the commit.

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.8.2";
 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"),

package/src/source.mjs

@@ -6,15 +6,58 @@
 //   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 { 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).
+export async function hostedCheckCli(opts, args, io = {}) {
+  const result = await hostedCheck(opts, args);
+  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])] };
+}
+
+// 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]");