Skip to content

Open-source platform for 3D AI agents. Turn text or a photo into a rigged, animated GLB avatar, give it an LLM brain, memory and a wallet, and embed it anywhere with one web component. Remote MCP server, x402 payments, Three.js, browser-native.

feat(marketing): narrate the product demo film and document how to record it

nirholasd5968a818189
diff --git a/docs/product-demo.md b/docs/product-demo.md
new file mode 100644
index 000000000..821222f9e
--- /dev/null
+++ b/docs/product-demo.md
@@ -0,0 +1,139 @@
+# Filming the product demo
+
+`npm run demo:video` records a narrated walkthrough of the whole platform: a presenter moving a real
+cursor through the live site, one feature at a time, with spoken narration and captions. It is the
+film you send someone who asks "what is three.ws, exactly?".
+
+Everything on screen is the real product answering in real time. There is no slideshow, no mock-up,
+and no staged data. If a page is broken on the day you film, it lands in the run report as a skipped
+stop instead of in the film as a still frame.
+
+```bash
+npm run demo:video # every feature, all chapters
+npm run demo:video:highlights # the short cut, the flagship stops only
+npm run demo:video -- --dry-run # print the route and exit
+npm run demo:video -- --sections=build # re-record one chapter
+```
+
+## What lands
+
+Output goes to `marketing/product-demo/`:
+
+| File | What it is |
+|---|---|
+| `three-ws-demo.mp4` | The whole film, all chapters joined |
+| `three-ws-demo-01-main.mp4` … | One file per chapter, in route order |
+| `demo-manifest.json` | What was filmed: origin, route, voice, stop count, chapter durations, and every skipped stop with the reason |
+
+The mp4s are gitignored on purpose. Each chapter is a 1080p screen recording and the set runs to
+hundreds of megabytes, which is not something a git history should carry forever. The manifest is
+committed, so the repo still records what was filmed and when. Re-run the script to get the film
+back.
+
+## The route is generated, not hand-written
+
+The stops come from [`public/tour/curriculum.json`](../public/tour/curriculum.json), the same
+curriculum the in-product [Feature Tour](../tour-sdk/README.md) walks, which
+[`scripts/build-tour.mjs`](../scripts/build-tour.mjs) generates from `data/pages.json`. Two things
+follow from that:
+
+- **A page that ships tomorrow is in the film.** Add it to `data/pages.json`, run
+ `npm run build:tour`, and the next recording visits it. Nothing here needs editing.
+- **The narration is the page's own description.** The words spoken over each stop are the same
+ plain-language sentences that feed the sitemap, `llms.txt`, and the changelog, so the film cannot
+ drift into claiming something the platform does not do.
+
+Chapters are the curriculum's sections, in its order: Main, Build, Crypto, Labs, Agent Tools, Learn.
+
+## Flagship stops are performed, not just visited
+
+Most stops are visited and read through the way a presenter scrolls a page they are showing you.
+About twenty surfaces get a hand-written act in the `ACTS` table at the top of
+[`scripts/make-product-demo.mjs`](../scripts/make-product-demo.mjs), and each one is a real
+interaction with the real page:
+
+- `/marketplace` is really searched, and the cards that answer are live 3D models
+- `/forge` really switches between the text, photo, and sketch lanes
+- `/create/prompt` really generates an avatar through the production pipeline
+- `/chat` really sends a message and waits for the model behind it to answer
+- `/pose` and `/playground` really turn their viewers with a pointer drag
+- `/holo` really drags the peel slider on the procedural foil
+
+An act also speaks: `beat('…')` says a line and waits it out, so the film keeps talking while it
+clicks instead of going silent on a surface that takes a moment. Add an act by adding a key to
+`ACTS` whose name is the stop's path.
+
+A selector that has gone missing does not fail the run. It fails that stop, which is recorded in
+`demo-manifest.json` under `skipped`, and the film moves on. Pass `--strict` when you want a missing
+selector to stop everything.
+
+## How it is filmed
+
+[`scripts/lib/demo-stage.mjs`](../scripts/lib/demo-stage.mjs) is the stage, and it is worth knowing
+three things about it.
+
+**Real time, not stepped frames.** The Seeker recordings
+([`docs/seeker-video.md`](./seeker-video.md)) step one frame at a time to reproduce a phone panel
+exactly. This does the opposite and uses Playwright's own recorder at 1920x1080, because a product
+demo is watched for its motion: 3D scenes streaming in, a model spinning under the cursor, a grid
+settling after a search. Stepped frames freeze all of that, and nearly every route here runs WebGL.
+
+**The cursor is a listener, not a puppet.** The arrow you see follows real `mousemove` and
+`mousedown` events that Playwright dispatches into the page, the same way a screen recorder draws
+the host cursor over a real session. It reports the interaction; it never stands in for one. Same
+for the click ring.
+
+**The voice is the platform's own.** Narration is synthesized through
+[`/api/tts/speak`](./api-reference.md), the free NVIDIA Magpie lane, so three.ws narrates three.ws.
+Clips are cached on their text under `marketing/product-demo/.raw/voice/`, so re-recording one
+chapter costs no synthesis and gets exactly the audio the full run would have given it. Captions
+carry the same words for anyone watching without sound.
+
+The narration track is laid down as a single exact concatenation of speech and silence at the
+offsets each line was spoken at, then muxed with the video. Nothing is mixed, so an hour-long film
+stays sample accurate end to end.
+
+## Flags
+
+| Flag | Effect |
+|---|---|
+| `--route=full` | Every feature page (default) |
+| `--route=highlights` | Only the curriculum's highlight stops |
+| `--sections=build,crypto` | Only these chapters |
+| `--limit=n` | First n stops per chapter, for a smoke test |
+| `--authed` | Replay the QA session, so signed-in surfaces are on screen |
+| `--origin=http://localhost:3000` | Film a dev server instead of production |
+| `--out=<dir>` | Write somewhere else |
+| `--voice=<id>` | Any voice from `/api/tts/voices` (default `nova`) |
+| `--no-voice` | Captions only, no narration track |
+| `--reuse` | Keep chapter mp4s that already exist, and film the rest |
+| `--strict` | A failed stop fails the run |
+| `--crf=<n>` | x264 quality, default 22; lower is bigger |
+| `--dry-run` | Print the route and exit |
+
+## Before you film
+
+- **`--authed` needs a session.** `npm run audit:web:login` mints one into `.auth/audit-state.json`
+ from the QA credentials in `.env`. Without it, the signed-in surfaces (x402 Studio, profile,
+ wallet) show their sign-in wall, and `/create/prompt` cannot start a real generation.
+- **`ffmpeg` and `ffprobe` must be on `PATH`** (`sudo apt-get install -y ffmpeg`). Playwright ships
+ its own ffmpeg, but that build is VP8-only with no filters, so it can do neither the H.264 encode
+ nor the audio mux.
+- **Check the disk.** A full run writes a raw webm per chapter before encoding it. Reclaim space
+ first with `npm run clean:worktrees -- --apply` if the workspace is tight.
+- **A full run takes about as long as the film.** It is a real-time recording of a real site, so
+ budget roughly an hour of wall clock for the full route, and film it in chapters (`--sections=`,
+ then `--reuse`) if you would rather not hold one process open that long.
+
+## Re-recording one chapter
+
+Chapters are independent recordings joined at the end, so a chapter that went wrong can be re-shot
+on its own:
+
+```bash
+npm run demo:video -- --sections=crypto # re-record just that chapter
+npm run demo:video -- --reuse # rejoin, keeping the chapters already on disk
+```
+
+`--reuse` skips any chapter whose mp4 is already in the output directory and films the rest, then
+concatenates all of them into `three-ws-demo.mp4`.
diff --git a/package.json b/package.json
index da307ed1e..6843e1df0 100644
--- a/package.json
+++ b/package.json
@@ -172,6 +172,8 @@
"build:dapp-store-previews": "node solana-mobile/scripts/make-screenshots.mjs",
"seeker:screencast": "node solana-mobile/scripts/make-screencast.mjs",
"seeker:feature-tour": "node solana-mobile/scripts/make-feature-tour.mjs --authed",
+ "demo:video": "node scripts/make-product-demo.mjs --authed",
+ "demo:video:highlights": "node scripts/make-product-demo.mjs --authed --route=highlights",
"render:pumpfun-verified": "node scripts/render-pumpfun-verified.mjs",
"build:ibm-shell": "node scripts/build-ibm-shell.mjs",
"i18n": "npm run i18n:extract && npm run i18n:translate",
diff --git a/scripts/make-product-demo.mjs b/scripts/make-product-demo.mjs
index 21850551b..36603ae7c 100644
--- a/scripts/make-product-demo.mjs
+++ b/scripts/make-product-demo.mjs
@@ -106,141 +106,185 @@ function lineFor(stop) {
* with the real page: nothing here fakes a result, and a selector that has gone
* missing surfaces as a skipped stop rather than a still frame.
*/
+/*
+ * A hand-written act for a flagship surface: the real interaction a presenter
+ * would perform, with the lines they would say while performing it. `beat`
+ * speaks a line and waits it out, so the film is never clicking in silence and
+ * never talking over a page that has not arrived yet.
+ *
+ * Nothing here fakes a result. A selector that has gone missing surfaces as a
+ * skipped stop in the run report rather than as a still frame in the film.
+ */
const ACTS = {
- '/': async (p) => {
- await p.hover('.nav-trigger:has-text("Build")', { hold: 1300 });
- await p.hover('.nav-trigger:has-text("Discover")', { hold: 1300 });
+ '/': async (p, { beat }) => {
+ await p.hover('.nav-trigger:has-text("Build")', { hold: 1200 });
+ await beat('The whole platform hangs off three menus. Build is where you make things.');
+ await p.hover('.nav-trigger:has-text("Discover")', { hold: 1200 });
+ await beat('Discover is where you find what everybody else has already made.');
await p.page.keyboard.press('Escape').catch(() => {});
- await p.readDown(700, { ms: 1500 });
- await p.type('#hero-forge-input', 'a brass astrolabe on a walnut stand', { cps: 17, settle: 900 });
- await p.readThrough({ budgetMs: 5000 });
+ await p.type('#hero-forge-input', 'a brass astrolabe on a walnut stand', { cps: 17, settle: 700 });
+ await beat('The front page has a forge in it. Describe an object, and a real textured 3D model comes back in about a minute. No sign up.');
+ await p.readThrough({ budgetMs: 4500 });
},
- '/what-is': async (p) => { await p.readThrough({ budgetMs: 7000 }); },
+ '/what-is': async (p, { beat }) => {
+ await p.readThrough({ budgetMs: 5000 });
+ await beat('A 3D agent is three things at once: a body you can see, a brain you can talk to, and a wallet it can spend from.');
+ },
- '/discover': async (p) => {
- await p.type('input[placeholder*="Search by name"]', 'agent', { cps: 13, settle: 1400 });
- await p.clickIfPresent('button.tws-lc-chip:has-text("All agents")', { after: 1600 });
+ '/discover': async (p, { beat }) => {
+ await p.type('input[placeholder*="Search by name"]', 'agent', { cps: 13, settle: 1200 });
+ await beat('Every agent here is registered on chain, on Solana and on the E R C 8004 registries, so the directory is not ours to fake.');
+ await p.clickIfPresent('button.tws-lc-chip:has-text("All agents")', { after: 1500 });
await p.readDown(760, { ms: 1500 });
},
- '/marketplace': async (p) => {
- await p.type('#market-search', 'knight', { cps: 12, settle: 1600 });
- await p.clickIfPresent('button.market-chip:has-text("Avatars")', { after: 1800 });
+ '/marketplace': async (p, { beat }) => {
+ await p.type('#market-search', 'knight', { cps: 12, settle: 1400 });
+ await beat('Those cards are live 3D models, not thumbnails. Every one of them is rendering in the browser right now.');
+ await p.clickIfPresent('button.market-chip:has-text("Avatars")', { after: 1600 });
await p.readDown(820, { ms: 1600 });
- await p.hover('#market-grid a.title.card-profile-link', { hold: 900 });
+ await p.hover('#market-grid a.title.card-profile-link', { hold: 800 });
},
- '/create-agent': async (p) => {
- await p.readThrough({ budgetMs: 6000 });
+ '/create-agent': async (p, { beat }) => {
+ await p.readThrough({ budgetMs: 5000 });
+ await beat('Name, body, skills, personality, voice, wallet. Six steps, and the agent exists at its own address on the web.');
},
- '/create/prompt': async (p) => {
- await p.type('#prompt', 'a medieval knight in battered steel plate, weathered red cloak', { cps: 16, settle: 900 });
- const fired = await p.clickIfPresent('#generate-btn', { after: 2200 });
- if (!fired) return;
- /* The real pipeline, at its real pace. The film watches the progress the
- page reports for as long as the budget allows and then moves on; the
- build keeps running on the server either way. */
- const deadline = Date.now() + 42_000;
+ '/create/prompt': async (p, { beat }) => {
+ await p.type('#prompt', 'a medieval knight in battered steel plate, weathered red cloak', { cps: 16, settle: 700 });
+ const fired = await p.clickIfPresent('#generate-btn', { after: 2000 });
+ if (!fired) {
+ await beat('One sentence in, a rigged humanoid out. The pipeline generates the mesh, textures it, and fits a skeleton to it.');
+ return;
+ }
+ await beat('That is the real pipeline running: a mesh generated from the words, textured, then rigged with a humanoid skeleton so it can be animated.');
+ const deadline = Date.now() + 60_000;
+ let spoke = false;
while (Date.now() < deadline) {
if (await p.page.locator('.step[data-step="done"].active').isVisible().catch(() => false)) break;
if (await p.page.locator('#build-error.show').isVisible().catch(() => false)) break;
+ if (!spoke && Date.now() > deadline - 42_000) {
+ spoke = true;
+ await beat('It takes about a minute. The progress you are watching is the job reporting its own stages, not a loading animation.');
+ }
await sleep(700);
}
if (await p.page.locator('#done-model').isVisible().catch(() => false)) {
- await sleep(2500);
+ await sleep(2000);
await p.dragAcross('#done-model', { dx: 260, ms: 1300 });
+ await beat('There it is, turning under the cursor. That model is yours to download, embed, or sell.');
}
},
- '/forge': async (p) => {
- await p.type('#prompt', 'a worn leather armchair, studio lit', { cps: 16, settle: 700 });
- await p.clickIfPresent('#tab-image', { after: 1500 });
- await p.clickIfPresent('#tab-sketch', { after: 1500 });
- await p.clickIfPresent('#tab-text', { after: 1200 });
+ '/forge': async (p, { beat }) => {
+ await p.type('#prompt', 'a worn leather armchair, studio lit', { cps: 16, settle: 600 });
+ await beat('The Forge is the same engine without the skeleton: any object, not just humanoids.');
+ await p.clickIfPresent('#tab-image', { after: 1300 });
+ await beat('It takes photographs too.');
+ await p.clickIfPresent('#tab-sketch', { after: 1300 });
+ await beat('Or a sketch. Several generation engines sit behind these tabs, each with live health status, and the request goes to whichever one is up.');
+ await p.clickIfPresent('#tab-text', { after: 1100 });
await p.readDown(900, { ms: 1600 });
- await p.clickIfPresent('button.showcase-sort-btn:has-text("Top this week")', { after: 1800 });
+ await p.clickIfPresent('button.showcase-sort-btn:has-text("Top this week")', { after: 1600 });
},
- '/pose': async (p) => {
+ '/pose': async (p, { beat }) => {
await p.dragAcross('#pose-canvas', { dx: 320, ms: 1400 });
- await p.clickIfPresent('button.mode-btn:has-text("IK")', { after: 1200 });
- await p.type('#pose-bone-search', 'arm', { cps: 10, settle: 1200 });
+ await beat('Any avatar on the platform can be posed here, bone by bone.');
+ await p.clickIfPresent('button.mode-btn:has-text("IK")', { after: 1100 });
+ await beat('Forward kinematics for single joints, inverse kinematics when you want to drag a hand and let the arm follow.');
+ await p.type('#pose-bone-search', 'arm', { cps: 10, settle: 1000 });
},
- '/playground': async (p) => {
+ '/playground': async (p, { beat }) => {
await p.dragAcross('#viewer', { dx: 340, ms: 1400 });
- await p.clickIfPresent('button.pill:has-text("Midnight")', { after: 1400 });
- await p.clickIfPresent('button.pill:has-text("Warm")', { after: 1400 });
- await p.clickIfPresent('#copy-embed', { after: 1400 });
+ await beat('This is the embed, running exactly as it would on your own site.');
+ await p.clickIfPresent('button.pill:has-text("Midnight")', { after: 1200 });
+ await p.clickIfPresent('button.pill:has-text("Warm")', { after: 1200 });
+ await beat('Lighting, background, shadow, auto rotate: every option here is an attribute on the tag.');
+ await p.clickIfPresent('#copy-embed', { after: 1200 });
+ await beat('And that is the snippet. Two lines of HTML, and the avatar is on your page.');
},
- '/brain': async (p) => {
- await p.type('#brDescribeInput', 'a sharp crypto trader who speaks in plain English', { cps: 16, settle: 900 });
- await p.clickIfPresent('#brBuildPersonaBtn', { after: 3200 });
- await p.clickIfPresent('button.br-tab:has-text("Playground")', { after: 2000 });
+ '/brain': async (p, { beat }) => {
+ await p.type('#brDescribeInput', 'a sharp crypto trader who speaks in plain English', { cps: 16, settle: 700 });
+ await beat('Describe the personality you want and the platform writes the system prompt for it.');
+ await p.clickIfPresent('#brBuildPersonaBtn', { after: 3000 });
+ await p.clickIfPresent('button.br-tab:has-text("Playground")', { after: 1800 });
+ await beat('The playground sends one prompt to several models at once, side by side, with latency and token counts, so you can pick the brain on evidence.');
},
- '/chat': async (p) => {
+ '/chat': async (p, { beat }) => {
const box = 'textarea[placeholder*="Type a message"]';
if (!(await p.page.locator(box).count())) return;
- await p.type(box, 'What can you build for me?', { cps: 15, settle: 500 });
+ await p.type(box, 'What can you build for me?', { cps: 15, settle: 400 });
await p.page.keyboard.press('Enter');
- await p.page.waitForTimeout(1200);
- for (let i = 0; i < 22; i += 1) {
- const answered = await p.page.evaluate(() => document.body.innerText.length).catch(() => 0);
- if (answered > 1200) break;
- await sleep(700);
- }
- await sleep(3500);
+ await beat('That is a real model answering, with tools and skills attached to it, and a wallet it can pay with.');
+ await sleep(2500);
+ await p.readDown(400, { ms: 900 });
},
- '/agents': async (p) => {
- await p.type('#ag-search', 'trader', { cps: 12, settle: 1500 });
+ '/agents': async (p, { beat }) => {
+ await p.type('#ag-search', 'trader', { cps: 12, settle: 1300 });
+ await beat('Every agent anyone has built on three dot w s, searchable, each with its own page.');
await p.readDown(700, { ms: 1400 });
},
- '/pay': async (p) => {
- await p.clickIfPresent('button.chain-tab:has-text("BNB")', { after: 1500 });
- await p.clickIfPresent('button.chain-tab:has-text("Solana")', { after: 1500 });
- await p.type('#prompt', 'validate https://example.com', { cps: 16, settle: 900 });
- await p.readThrough({ budgetMs: 4000 });
+ '/pay': async (p, { beat }) => {
+ await beat('This is machine to machine payment. An A P I answers a request with a price instead of a refusal, and the agent pays it.');
+ await p.clickIfPresent('button.chain-tab:has-text("BNB")', { after: 1300 });
+ await p.clickIfPresent('button.chain-tab:has-text("Solana")', { after: 1300 });
+ await p.type('#prompt', 'validate https://example.com', { cps: 16, settle: 700 });
+ await beat('Solana first, in U S D C, settling in under a second and costing a fraction of a cent.');
+ await p.readThrough({ budgetMs: 3500 });
},
- '/launch': async (p) => { await p.readThrough({ budgetMs: 7000 }); },
+ '/launch': async (p, { beat }) => {
+ await p.readThrough({ budgetMs: 5000 });
+ await beat('An agent can have its own coin, minted on pump dot fun from inside the platform, with the agent as the thing it is attached to.');
+ },
- '/markets': async (p) => {
+ '/markets': async (p, { beat }) => {
await p.readDown(900, { ms: 1600 });
- await p.clickIfPresent('button.nw-star', { after: 1200 });
+ await beat('Live prices, news, screeners and on chain intelligence, so an agent that trades has something to trade on.');
+ await p.clickIfPresent('button.nw-star', { after: 1100 });
await p.readDown(1100, { ms: 1700 });
},
- '/holo': async (p) => {
- await p.clickIfPresent('button.hs-chip:has-text("$THREE")', { after: 1400 });
+ '/holo': async (p, { beat }) => {
+ await p.clickIfPresent('button.hs-chip:has-text("$THREE")', { after: 1300 });
await p.slideTo('#peelRange', 0.72, { ms: 1500 });
+ await beat('Every pixel of that foil is procedural. No image assets, no video, just shaders running in the page.');
await p.slideTo('#peelRange', 0.12, { ms: 1200 });
},
- '/labs': async (p) => {
- await p.clickIfPresent('button.labs-filter:has-text("x402")', { after: 1600 });
- await p.clickIfPresent('button.labs-filter:has-text("All")', { after: 1200 });
+ '/labs': async (p, { beat }) => {
+ await p.clickIfPresent('button.labs-filter:has-text("x402")', { after: 1500 });
+ await beat('Labs is the drawer everything experimental lives in, and most of it ends up shipping.');
+ await p.clickIfPresent('button.labs-filter:has-text("All")', { after: 1100 });
await p.readDown(820, { ms: 1600 });
},
- '/diorama': async (p) => {
- await p.clickIfPresent('button.dio-chip', { after: 1600 });
- await p.type('#compose-input', 'a cliffside lighthouse in a storm', { cps: 16, settle: 900 });
+ '/diorama': async (p, { beat }) => {
+ await p.clickIfPresent('button.dio-chip', { after: 1500 });
+ await p.type('#compose-input', 'a cliffside lighthouse in a storm', { cps: 16, settle: 700 });
+ await beat('Same idea as the forge, but for whole scenes: describe a little world and it gets built around you.');
await p.readDown(600, { ms: 1400 });
},
- '/walk': async (p) => {
+ '/walk': async (p, { beat }) => {
await p.readDown(760, { ms: 1500 });
- await p.clickIfPresent('#wl-copy', { after: 1400 });
- await p.readThrough({ budgetMs: 4500 });
+ await beat('Your avatar can walk across any website that carries the tag, not just ours. It is a script tag and a model URL.');
+ await p.clickIfPresent('#wl-copy', { after: 1300 });
+ await p.readThrough({ budgetMs: 3500 });
},
- '/profile': async (p) => { await p.readThrough({ budgetMs: 6000 }); },
+ '/docs': async (p, { beat }) => {
+ await p.readThrough({ budgetMs: 4500 });
+ await beat('Every surface in this film has an A P I, an S D K, and a page in here explaining it.');
+ },
};
/**
@@ -331,19 +375,29 @@ try {
log(`chapter ${ci + 1}/${chapters.length}: ${chapter.title} (${chapter.stops.length} stops)`);
/* Open on the chapter's first page so the title card sits over the real
- product rather than over a blank tab. */
+ product rather than over a blank tab. The card carries the words while
+ they are spoken, so the caption bar stays out of its way. */
const first = chapter.stops[0];
await page.goto(`${ORIGIN}${first.path}`, { waitUntil: 'domcontentloaded', timeout: 60_000 }).catch(() => {});
await page.waitForTimeout(2600);
await p.ready();
- await p.chapter(`Chapter ${ci + 1}`, chapter.title, say(chapter.intro).slice(0, 190));
+ await p.showCursor(false);
if (ci === 0) {
- const until = await narrator.say(p, say(OPENING), { kicker: 'three.ws' });
+ /* The opening already welcomes the viewer, so chapter one does not
+ also read the guide's own welcome line back to them. */
+ await p.chapter('', 'three.ws', say(OPENING));
+ const until = await narrator.say(p, say(OPENING), { caption: false });
await narrator.settle(until);
+ await p.chapter('Chapter 1', chapter.title, '');
+ await sleep(2600);
} else {
- await sleep(3000);
+ const intro = say(chapter.intro);
+ await p.chapter(`Chapter ${ci + 1}`, chapter.title, intro);
+ const introUntil = await narrator.say(p, intro, { caption: false });
+ await narrator.settle(introUntil);
}
await p.chapter('', '', '');
+ await p.showCursor(true);
await sleep(700);
for (const [si, stop] of chapter.stops.entries()) {
@@ -360,8 +414,16 @@ try {
await page.waitForLoadState('load', { timeout: 20_000 }).catch(() => {});
await sleep(stop.highlight ? 1800 : 900);
await p.ready();
- const act = ACTS[stop.path] || ((ctxp) => genericAct(ctxp, stop));
- await act(p, stop);
+ /* A line spoken from inside an act: the presenter keeps talking
+ while they click, which is what keeps the film from clicking
+ in silence on the surfaces that take a while to show. */
+ const beat = async (text) => {
+ const line = say(text);
+ const done = await narrator.say(p, line, { kicker: chapter.title });
+ await narrator.settle(done, { tail: 260 });
+ };
+ const act = ACTS[stop.path] || ((pp, c) => genericAct(pp, c.stop));
+ await act(p, { stop, beat, page });
await narrator.settle(until);
log(` ${at} ${stop.path}`);
} catch (err) {
@@ -374,9 +436,11 @@ try {
if (ci === chapters.length - 1) {
await p.caption('', '');
- await p.chapter('three.ws', 'Build one yourself', 'three.ws');
- const until = await narrator.say(p, say(CLOSING), { kicker: '' });
- await narrator.settle(until, { tail: 1200 });
+ await p.badge('');
+ await p.showCursor(false);
+ await p.chapter('', 'three.ws', say(CLOSING));
+ const until = await narrator.say(p, say(CLOSING), { caption: false });
+ await narrator.settle(until, { tail: 1400 });
}
const spanMs = Date.now() - t0;