diff --git a/docs/teaser/shot-script.md b/docs/teaser/shot-script.md
index 627b4dd..881cfec 100644
--- a/docs/teaser/shot-script.md
+++ b/docs/teaser/shot-script.md
@@ -1,20 +1,24 @@
 # Teaser shot script
 
-The teaser on the landing page: one continuous board session, recorded long and cut
-down. The shipped cut runs 42 seconds. The same master serves the home page, the Store
-trailer, and announcements. It is served from the site itself, not embedded — decision 19
-in [../decisions.md](../decisions.md).
+The teaser on the landing page is film 2 of [tools/films](../../tools/films/README.md),
+"One board". The shipped cut runs 50 seconds: one continuous camera move across a single
+board on which seven screen captures sit as windows, ending on the whole board and the end
+card. It names no date and no deadline, so it does not go out of date when the campaign
+ends. The same master serves the home page, the Store trailer, the social renditions,
+and three 12-second portrait shorts. The site serves it itself, not through an embed —
+decision 19 in [../decisions.md](../decisions.md).
 
-Everything the recording needs is in this folder:
+It replaced a 42-second cut of one continuous board session, recorded and edited by hand.
+The staging files for that recording are still in this folder:
 
 | File | Used in |
 | --- | --- |
 | `shot-script.md` | This script |
-| `demo-board.wimport` | Beat 3 — the drop that fills the board |
-| `paste-me.dax` | Beat 2 — copy its contents to the clipboard before recording |
+| `demo-board.wimport` | The drop that filled the board in the 42-second cut |
+| `paste-me.dax` | The measure pasted in the 42-second cut |
 | `assets/star-schema.png`, `assets/sales-trend.png` | Referenced by the recipe |
 | `make-assets.ps1` | Regenerates the two PNGs if they change |
-| `overlays/ctrl-v.png`, `overlays/f6.png` | Keystroke callouts for the edit (beats 2's paste and F6) |
+| `overlays/ctrl-v.png`, `overlays/f6.png` | Keystroke callouts for a hand edit |
 | `make-overlays.ps1` | Regenerates the overlays if they change |
 
 ## Recording setup
@@ -28,85 +32,64 @@ Everything the recording needs is in this folder:
   window region only). Default white board, default toolbar position.
 - Pen: the Cintiq Pro profile already validated in README § "Wacom Cintiq Pro validation".
 
-## Staging, before every take
+The captures of the shipped cut were recorded at 30 fps, `ink-diagram.mp4` at
+3840 × 2160 and the other six at 1920 × 1080, so the master is 1920 × 1080 at 30 fps.
+The film never shows a capture larger than it was recorded. A re-recording at
+2560 × 1440 can be placed on the board at the same size in board units without
+changing anything else.
 
-1. Open **Help → Preferences → Snippet format order** and move **DAX above Plain text**,
-   so the paste in beat 2 lands already highlighted. (Restore afterwards if you prefer
-   plain-first day to day.)
-2. Copy the contents of `paste-me.dax` to the clipboard **as text** (open it in a text
-   editor and Ctrl+A, Ctrl+C — do not copy the file in Explorer, because a copied file is
-   pasted as a file rather than as text).
-3. Open a File Explorer window showing this folder, positioned on a second monitor or
-   off-canvas, ready to drag `demo-board.wimport`.
-4. Start the LiveView target for beat 5: **Power BI Desktop** with a report page visible
-   (any demo model — it only needs to look alive). Second monitor, or behind the app.
-5. New empty board, Pen tool, default zoom.
+## The shot list
 
-## The beats
+Each capture is a window on the board with its caption written below it. The camera is
+the only thing that moves: it rests on a window with a slow push-in, moves to the next
+with one ease-in-out curve and a slight pull back mid-move, and never cuts. The captures
+play faster than recorded where the beat is shorter than the capture; the times and rates
+are in `tools/films/src/film2/cuts.ts`.
 
-Timings are the *edited* target. Record each beat at natural speed; the cuts and
-speed-ups happen in the edit. Total real time per take: 3–5 minutes.
-
-| # | Edited | Action, exactly | Must be visible |
+| Time | Camera | Capture | Caption on the board |
 | --- | --- | --- | --- |
-| 1 | 0–5 s | On the empty board, handwrite **"Contoso — sales review"** and underline it. Vary pressure; this beat stays real-time in the edit, it is the "feel" shot. | Wet ink following the pen with no lag; pressure width variation; the hover dot before contact. |
-| 2 | 5–11 s | Click empty canvas below the title, **Ctrl+V**. The measure appears as a DAX container, highlighted, crammed on long lines. Press **F6**. It reformats in place. | Syntax colors on paste; the visible before/after of F6. |
-| 3 | 11–16 s | Drag **`demo-board.wimport`** from Explorer onto the right half of the board. Five containers materialize: two images, DAX, SQL, notes. | The one-gesture board build. Pause a beat so the layout registers. |
-| 4 | 16–21 s | With the pen, circle the December column on the **Sales by month** chart and draw a short arrow — strokes must stay entirely on that one image. Then left-drag the chart container to a clearer spot. | The ink travels with the container. This is the "aha" beat; move it far enough to be unmistakable. |
-| 5 | 21–26 s | **View → LiveView**, pick the Power BI Desktop window in the system picker, place it. Ink one arrow onto the live feed, then **View → Freeze**. | A real application, live inside the board, annotated. The picker dialog gets jump-cut to ~1 s in the edit. |
-| 6 | 26–30 s | Click empty canvas, then **double-click empty canvas**: the camera fits the whole board. Hold two seconds. | The zoom-to-fit reveal: title ink, formatted DAX, the dropped board, annotated chart, frozen LiveView — one composition. |
-
-Notes that keep beats honest:
-
-- Beat 4's strokes link only if they touch **exactly one** container — keep the circle and
-  arrow fully on the chart image, not grazing a neighbor.
-- The tab strip appears on camera in beat 5 (View tab) — that covers the tab-strip
-  requirement without its own beat.
-- Optional touch: one short two-finger pan somewhere between beats 3 and 4 shows touch
-  navigation. Finger drawing is shown in a Store screenshot instead, because 30 s is too
-  short to include it.
-- Optional end card: before the take, handwrite **whiteboard.sqlbi.com** small near the
-  board's edge; beat 6's fit reveals it without an overlay.
-
-## Takes
-
-Rehearse the full sequence twice without recording — the handwriting beats are the only
-part that cannot be fixed in post. Then record **three to five full takes**, letting
-mistakes run (restart the beat on the same board rather than the take; the edit keeps the
-best pass of each beat). Name recordings `take-01.mkv`, `take-02.mkv`, …
-
-## Edit
-
-- Jump cuts only. Every cut lands on the same white board with more content — no
-  transitions needed.
-- Beat 1 stays 1× always. Dialogs (capture picker) and any dead pen travel get cut or
-  sped to 4×. Keep at least one second of stillness after beats 3 and 6.
-- Keystroke callouts: overlay `overlays/ctrl-v.png` on the paste and `overlays/f6.png` on
-  the format in beat 2 — transparent PNGs, drawn large; scale to taste (a keycap about
-  1/10 of the frame height reads well), bottom-right corner, quick fade in and out.
-- No voiceover. Music optional, added at upload; the clip must work silent.
-- Export master: **2560 × 1440, 60 fps, H.264 high bitrate** (or ProRes/DNxHR if the
-  editor offers it), audio track only if music was added.
+| 0–6 s | Rests on D1 | `ink-diagram.mp4`: the pen draws three boxes and two connectors | SQLBI Whiteboard |
+| 6–13 s | Pans right to D2 | `liveview-powerbi.mp4`: View, LiveView, the Power BI window lands, Freeze, highlighter marks | Capture a running application onto the board and draw on it. |
+| 13–20 s | Pans down to D3 | `dax-f6.mp4`: a one-line measure is pasted, F6 formats it | Paste DAX or SQL. F6 formats it. |
+| 20–27 s | Pans left to D4, past D7 | `shapes-connectors.mp4`: a rectangle, a diamond, a connector; the rectangle moves and the arrow follows | Shapes, sticky notes, and arrows that follow. |
+| 27–34 s | Pans up to D5 | `frames-export.mp4`: Export to PowerPoint and the deck open in PowerPoint | Frames become slides. Export the deck. |
+| 34–41 s | Pans down and left to D6 | `open-pptx-zip.mp4`: a .pptx dropped on the board becomes its slides | Open a PowerPoint deck or a Microsoft Whiteboard export. |
+| 41–47 s | Pulls back until the whole board is in frame | `full-board.mp4` at the centre of the board: a double-click fits the board in its window as the camera pulls back | One board. A file on your PC. |
+| 47–50 s | The board gives way to the end card | | App icon, SQLBI Whiteboard, Free and open source, whiteboard.sqlbi.com |
+
+The site rendition loops, so its end card fades to paper over the last 500 ms and the
+restart cuts to the white board of the first frame. No rendition has a voice. The site
+files are silent; the social files and the Store trailer carry the music bed.
+
+The shorts take the LiveView, DAX, and shapes stations: 10 seconds on the station with
+the capture at its own speed, and a 2-second end card.
 
 ## Publish
 
-The site serves the clip itself (decision 19). From the 4K master, encode the two
+`npm run render:film2-site` in `tools/films` renders the master
+(`out/master/film2-16x9-master.mp4`) and runs these three commands, which write the two
 renditions and the poster straight into `site/`; they deploy with the next site publish.
 
 ```bash
-ffmpeg -y -i master.mp4 -vf "scale=2560:-2:flags=lanczos" -c:v libsvtav1 -crf 38 -preset 6 -movflags +faststart -an site/teaser-av1.mp4
+ffmpeg -y -i master.mp4 -vf "scale=1920:-2:flags=lanczos,fade=t=out:st=49.5:d=0.5:color=0xF7F6F2" -c:v libsvtav1 -crf 46 -preset 6 -movflags +faststart -an site/teaser-av1.mp4
 ```
 
 ```bash
-ffmpeg -y -i master.mp4 -vf "scale=1920:-2:flags=lanczos" -c:v libx264 -crf 22 -preset slow -pix_fmt yuv420p -movflags +faststart -an site/teaser-h264.mp4
+ffmpeg -y -i master.mp4 -vf "scale=1920:-2:flags=lanczos,fade=t=out:st=49.5:d=0.5:color=0xF7F6F2" -c:v libx264 -crf 31 -preset veryslow -pix_fmt yuv420p -movflags +faststart -an site/teaser-h264.mp4
 ```
 
 ```bash
-ffmpeg -y -ss 41.0 -i master.mp4 -frames:v 1 -vf "scale=1920:-2:flags=lanczos" -q:v 3 site/teaser-poster.jpg
+ffmpeg -y -ss 46.0 -i master.mp4 -frames:v 1 -vf "scale=1920:-2:flags=lanczos" -q:v 3 site/teaser-poster.jpg
 ```
 
-The `<video>` element in `site/index.html` lists the AV1 source first and H.264 as the
-fallback; if a re-encode changes resolution, frame rate, or codec profile, update its
-`codecs=` strings (read them with `ffprobe -show_entries stream=profile,level`). Keep
-the master outside the repository, and reuse it for the Store trailer per
+The CRFs are higher than those of the 42-second cut (38 and 22) because the camera never
+stops, so every frame differs from the one before. At 46 and 31 each file is about
+3.5 MB, the size of the 42-second cut, and the text of the captures and the captions stays
+readable, at rest and in the pans.
+
+The poster is the whole board at 46 seconds. The `<video>` element in `site/index.html`
+lists the AV1 source first and H.264 as the fallback; if a re-encode changes resolution,
+frame rate, or codec profile, update its `codecs=` strings (read them with
+`ffprobe -show_entries stream=profile,level`). The Store trailer is
+`out/film2-store-1920x1080.mp4` from `npm run render:film2-store`, for
 `installer/msix/STORE-LISTING.md`.
diff --git a/site/index.html b/site/index.html
index 1bd4a4f..873cf96 100644
--- a/site/index.html
+++ b/site/index.html
@@ -87,12 +87,12 @@ <h1>The whiteboard for <span class="accent">teaching</span></h1>
              blocked. Decision 19 in docs/decisions.md. -->
         <video controls autoplay muted loop playsinline
                poster="teaser-poster.jpg"
-               title="SQLBI Whiteboard, forty seconds">
-          <source src="teaser-av1.mp4" type='video/mp4; codecs="av01.0.12M.08"'>
-          <source src="teaser-h264.mp4" type='video/mp4; codecs="avc1.640032"'>
+               title="SQLBI Whiteboard, fifty seconds">
+          <source src="teaser-av1.mp4" type='video/mp4; codecs="av01.0.08M.08"'>
+          <source src="teaser-h264.mp4" type='video/mp4; codecs="avc1.640033"'>
         </video>
       </div>
-      <p class="launch-caption">Forty seconds on a board.</p>
+      <p class="launch-caption">Fifty seconds on one board.</p>
     </section>
   </div>
 </header>
diff --git a/site/teaser-av1.mp4 b/site/teaser-av1.mp4
index c85c409..202575d 100644
Binary files a/site/teaser-av1.mp4 and b/site/teaser-av1.mp4 differ
diff --git a/site/teaser-h264.mp4 b/site/teaser-h264.mp4
index 999f939..503dee7 100644
Binary files a/site/teaser-h264.mp4 and b/site/teaser-h264.mp4 differ
diff --git a/site/teaser-poster.jpg b/site/teaser-poster.jpg
index da9be52..01f64f2 100644
Binary files a/site/teaser-poster.jpg and b/site/teaser-poster.jpg differ
diff --git a/tools/films/README.md b/tools/films/README.md
index 34ededb..a6e99fc 100644
--- a/tools/films/README.md
+++ b/tools/films/README.md
@@ -7,6 +7,12 @@ Film 1, "Export before 16 October", is 30 seconds long. It tells people who use
 Microsoft Whiteboard app with a personal account to export their boards before the app
 retires on 16 October 2026, and shows SQLBI Whiteboard opening the exported ZIP.
 
+Film 2, "One board", is 50 seconds long. One continuous camera move crosses a single
+board on which seven captures sit as windows, each with its caption written below it,
+and ends on the whole board and the end card. It is the teaser on the site and the Store
+trailer, and three 12-second portrait shorts are cut from it. It names no date, so it
+stays true after the campaign.
+
 ## License
 
 Remotion is used under its free license, which applies to companies with up to three
@@ -59,6 +65,40 @@ come from one composition, whose layout in `src/layout.ts` follows the aspect ra
 
 Nothing under `out` is committed.
 
+### Film 2
+
+```powershell
+npm run stills:film2        # a still every 5 seconds of each composition, into out\stills
+npm run render:film2-all    # every rendition, into out, and the site files, into ..\..\site
+```
+
+One script renders each rendition: `render:film2-16x9`, `render:film2-1x1`,
+`render:film2-4x5`, `render:film2-short-liveview`, `render:film2-short-dax`,
+`render:film2-short-shapes`, `render:film2-store`, and `render:film2-site`. Each
+composition is rendered once at its own size into `out\master`, not at twice its size,
+because six of the captures are 1080p and a larger master would only enlarge them.
+
+| File | Size | Where it goes | Safe area |
+| --- | --- | --- | --- |
+| `film2-16x9.mp4` | 1920 × 1080 | YouTube, LinkedIn, X | 96 px on every side |
+| `film2-1x1.mp4` | 1080 × 1080 | LinkedIn feed, X, Instagram feed | 90 px |
+| `film2-4x5.mp4` | 1080 × 1350 | Instagram feed, LinkedIn | 90 px |
+| `film2-short-liveview.mp4` | 1080 × 1920 | Reels, TikTok, Shorts: the LiveView station | y 250 to 1550, x 60 to 930 |
+| `film2-short-dax.mp4` | 1080 × 1920 | Reels, TikTok, Shorts: the DAX and F6 station | y 250 to 1550, x 60 to 930 |
+| `film2-short-shapes.mp4` | 1080 × 1920 | Reels, TikTok, Shorts: the shapes station | y 250 to 1550, x 60 to 930 |
+| `film2-store-1920x1080.mp4` | 1920 × 1080 | The Microsoft Store trailer | 96 px |
+| `site/teaser-av1.mp4`, `site/teaser-h264.mp4` | 1920 × 1080 | The landing page, silent and looping | |
+| `site/teaser-poster.jpg` | 1920 × 1080 | The landing page poster, the whole board at 46 s | |
+
+The files in `out` are H.264 High, yuv420p, 30 fps, with the music bed in AAC at 128 kbps
+and the index at the start of the file. The film is exactly 50 seconds long and each short
+exactly 12, ending on a 2-second end card. The site files carry no audio, and their end
+card fades to paper over the last half second so the loop restarts on the white board;
+the commands are in [docs/teaser/shot-script.md](../../docs/teaser/shot-script.md).
+
+`src/film2/board.ts` lays out the board for each shape, and `src/film2/cuts.ts` holds
+the camera moves and the moment each capture plays, for the film and for each short.
+
 ## Captures
 
 Record with OBS at 2560 × 1440 and 60 fps, with Windows display scaling at 150 % and the
@@ -78,6 +118,23 @@ with its name and what it will show.
 it plays it, and where the numbered callouts sit. The callout positions are estimates, so
 check them against the real captures in `npm run studio` and correct them there.
 
+Film 2 uses seven more. They were recorded at 30 fps, `ink-diagram.mp4` at 3840 × 2160 and
+the others at 1920 × 1080. Each sits on the board at 1920 × 1080 and the camera never
+zooms past that, so no capture is shown larger than it was recorded.
+
+| # | File | Length | What it shows |
+| --- | --- | --- | --- |
+| D1 | `ink-diagram.mp4` | 8.6 s | The pen draws three boxes and two connectors, with pressure visible |
+| D2 | `liveview-powerbi.mp4` | 9.6 s | View, LiveView, the Power BI window on the board, Freeze, highlighter marks |
+| D3 | `dax-f6.mp4` | 9.2 s | A long one-line measure is pasted; F6 formats it |
+| D4 | `shapes-connectors.mp4` | 10.1 s | Insert: a rectangle, a diamond, and a connector; the rectangle moves and the arrow follows |
+| D5 | `frames-export.mp4` | 11.0 s | A board of slides, Export to PowerPoint, and the deck open in PowerPoint |
+| D6 | `open-pptx-zip.mp4` | 8.5 s | A .pptx dropped on the board becomes its slides |
+| D7 | `full-board.mp4` | 6.4 s | A double-click on empty canvas fits the whole board in the window |
+
+The lengths are those of the video tracks. `src/film2/captures.ts` records what happens
+when in each capture, read from frame sheets.
+
 ## Voice and music
 
 The voice is `audio\film1-vo.mp3`. [audio/film1-vo.txt](audio/film1-vo.txt) holds the
@@ -106,3 +163,15 @@ between two phrases, gives the wrong count; then set `src/film1/beats.json` by h
 The music bed, when there is one, is `audio\film1-bed.mp3`. It plays 22 dB below the voice
 and fades out under the end card. Without it the film has no music. The MP3 files are not
 committed.
+
+Film 2 has no voice. Its bed is `audio\film2-bed.mp3`, generated 60 seconds long because
+the generator fades out over its last 10 seconds, so the first 50 hold their level until
+the end card:
+
+```powershell
+node scripts\elevenlabs.mjs music --film film2 --seconds 60 --prompt "Calm, minimal instrumental. Soft felt piano and a warm, slowly evolving pad, unhurried and steady, gently optimistic, with an even level throughout. No drums, no percussion, no vocals. Suitable under a quiet product film with no narration. Ends with a gentle fade."
+```
+
+The render mixes it with ffmpeg at a level that averages −20 dB: from its start under
+the film, fading out over the end card, and from 14 seconds in under each short. Without
+it the files in `out` carry a silent track.
diff --git a/tools/films/package.json b/tools/films/package.json
index 4489c86..4ebc4c2 100644
--- a/tools/films/package.json
+++ b/tools/films/package.json
@@ -12,7 +12,17 @@
     "render:4x5": "node scripts/render.mjs 4x5",
     "render:9x16": "node scripts/render.mjs 9x16",
     "render:poster": "node scripts/render.mjs poster",
-    "render:all": "node scripts/render.mjs all"
+    "render:all": "node scripts/render.mjs all",
+    "stills:film2": "node scripts/stills.mjs film2",
+    "render:film2-16x9": "node scripts/render.mjs film2 16x9",
+    "render:film2-1x1": "node scripts/render.mjs film2 1x1",
+    "render:film2-4x5": "node scripts/render.mjs film2 4x5",
+    "render:film2-short-liveview": "node scripts/render.mjs film2 short-liveview",
+    "render:film2-short-dax": "node scripts/render.mjs film2 short-dax",
+    "render:film2-short-shapes": "node scripts/render.mjs film2 short-shapes",
+    "render:film2-store": "node scripts/render.mjs film2 store",
+    "render:film2-site": "node scripts/render.mjs film2 site",
+    "render:film2-all": "node scripts/render.mjs film2 all"
   },
   "dependencies": {
     "@remotion/bundler": "4.0.529",
diff --git a/tools/films/scripts/lib.mjs b/tools/films/scripts/lib.mjs
index 938da85..b0b57f4 100644
--- a/tools/films/scripts/lib.mjs
+++ b/tools/films/scripts/lib.mjs
@@ -27,6 +27,16 @@ export const ffmpeg = (args) => {
   if (r.status !== 0) throw new Error(`ffmpeg failed: ${args.join(' ')}`);
 };
 
+// The mean volume in dB of an audio file after an ffmpeg audio filter, read with
+// volumedetect.
+export const meanVolume = (file, filter) => {
+  const exe = process.env.FFMPEG ?? 'ffmpeg';
+  const r = spawnSync(exe, ['-hide_banner', '-i', file, '-af', `${filter},volumedetect`, '-f', 'null', '-'], {encoding: 'utf8'});
+  const m = /mean_volume: (-?[\d.]+) dB/.exec(r.stderr ?? '');
+  if (!m) throw new Error(`volumedetect found no level in ${file}`);
+  return Number(m[1]);
+};
+
 export const progressLogger = (label) => {
   let last = -1;
   return ({progress}) => {
diff --git a/tools/films/scripts/prepare-media.mjs b/tools/films/scripts/prepare-media.mjs
index 141dd52..6043e46 100644
--- a/tools/films/scripts/prepare-media.mjs
+++ b/tools/films/scripts/prepare-media.mjs
@@ -5,6 +5,7 @@ import {copyFileSync, existsSync, linkSync, mkdirSync, readdirSync, rmSync} from
 import {join} from 'node:path';
 import {pathToFileURL} from 'node:url';
 import {captures} from '../src/film1/captures.ts';
+import {captures as film2Captures} from '../src/film2/captures.ts';
 import {root} from './lib.mjs';
 
 export const prepareMedia = () => {
@@ -26,11 +27,12 @@ export const prepareMedia = () => {
   }
 
   const has = (p) => existsSync(join(pub, p));
-  for (const c of captures) {
+  for (const c of [...captures, ...Object.values(film2Captures)]) {
     console.log(`${c.id} ${c.file}: ${has(`captures/${c.file}`) ? 'present' : 'missing, placeholder shown'}`);
   }
   console.log(`Voice audio/film1-vo.mp3: ${has('audio/film1-vo.mp3') ? 'present' : 'missing, silent track'}`);
   console.log(`Music audio/film1-bed.mp3: ${has('audio/film1-bed.mp3') ? 'present' : 'missing, no music'}`);
+  console.log(`Music audio/film2-bed.mp3: ${has('audio/film2-bed.mp3') ? 'present' : 'missing, silent track'}`);
 };
 
 if (import.meta.url === pathToFileURL(process.argv[1]).href) {
diff --git a/tools/films/scripts/render.mjs b/tools/films/scripts/render.mjs
index 27ea30d..bb278cd 100644
--- a/tools/films/scripts/render.mjs
+++ b/tools/films/scripts/render.mjs
@@ -1,88 +1,215 @@
-// Renders the film for the platforms, into out/.
-//   node scripts/render.mjs 16x9 | 1x1 | 4x5 | 9x16 | poster | all
+// Renders the films for the platforms, into out/.
+//   node scripts/render.mjs 16x9 | 1x1 | 4x5 | 9x16 | poster | all             film 1
+//   node scripts/render.mjs film2 16x9 | 1x1 | 4x5 | short-liveview | short-dax |
+//                                 short-shapes | store | site | all            film 2
 //
-// Each shape is rendered once at twice its size (3840 x 2160 for 16:9) into
+// Film 1: each shape is rendered once at twice its size (3840 x 2160 for 16:9) into
 // out/master/, then scaled down with ffmpeg into the H.264 file the platforms take.
-import {mkdirSync} from 'node:fs';
+//
+// Film 2: each composition is rendered once at its own size into out/master/, because
+// its captures are 1080p and a larger master would only enlarge them. The renditions are
+// encoded from there, with the music bed mixed in by ffmpeg; `site` writes the two
+// teaser files and the poster into site/ at the root of the repository.
+import {existsSync, mkdirSync} from 'node:fs';
 import {join} from 'node:path';
 import {renderMedia, renderStill, selectComposition} from '@remotion/renderer';
 import beats from '../src/film1/beats.json' with {type: 'json'};
+import {film2Compositions} from '../src/film2/compositions.ts';
+import {cuts} from '../src/film2/cuts.ts';
 import {shapes} from '../src/layout.ts';
-import {browserOptions, ffmpeg, makeBundle, out, progressLogger} from './lib.mjs';
+import {browserOptions, ffmpeg, makeBundle, meanVolume, out, progressLogger, root} from './lib.mjs';
 import {prepareMedia} from './prepare-media.mjs';
 
 const FPS = 30;
-const DURATION = beats.durationSeconds;
 const master = join(out, 'master');
 
-const targets = process.argv.slice(2);
-if (targets.length === 0) {
-  console.error('Name a rendition: 16x9, 1x1, 4x5, 9x16, poster, or all.');
-  process.exit(1);
+const args = process.argv.slice(2);
+if (args[0] === 'film2') {
+  await renderFilm2(args.slice(1));
+} else {
+  await renderFilm1(args);
+}
+
+async function renderFilm1(targets) {
+  const DURATION = beats.durationSeconds;
+  if (targets.length === 0) {
+    console.error('Name a rendition: 16x9, 1x1, 4x5, 9x16, poster, or all.');
+    process.exit(1);
+  }
+  const all = targets.includes('all');
+  const shapeList = shapes.filter((s) => all || targets.includes(s.id));
+  const poster = all || targets.includes('poster');
+
+  prepareMedia();
+  mkdirSync(master, {recursive: true});
+  const serveUrl = await makeBundle();
+
+  for (const s of shapeList) {
+    const inputProps = {shapeId: s.id};
+    const composition = await selectComposition({serveUrl, id: `film1-${s.id}`, inputProps, ...browserOptions()});
+    const masterFile = join(master, `film1-${s.id}-master.mp4`);
+    await renderMedia({
+      composition,
+      serveUrl,
+      inputProps,
+      codec: 'h264',
+      outputLocation: masterFile,
+      scale: 2,
+      crf: 12,
+      imageFormat: 'jpeg',
+      jpegQuality: 95,
+      pixelFormat: 'yuv420p',
+      // A silent track stands in for the voice until audio/film1-vo.mp3 exists.
+      enforceAudioTrack: true,
+      audioCodec: 'aac',
+      audioBitrate: '320k',
+      onProgress: progressLogger(`film1-${s.id} master`),
+      ...browserOptions(),
+    });
+
+    const file = join(out, `film1-${s.id}.mp4`);
+    ffmpeg([
+      '-y',
+      '-i', masterFile,
+      // The master is flagged full range; the platforms expect limited range.
+      '-vf', `scale=${s.width}:${s.height}:flags=lanczos:out_range=tv,format=yuv420p`,
+      '-color_range', 'tv',
+      '-c:v', 'libx264',
+      '-profile:v', 'high',
+      '-preset', 'slow',
+      '-crf', '20',
+      '-pix_fmt', 'yuv420p',
+      '-r', String(FPS),
+      '-c:a', 'aac',
+      '-b:a', '128k',
+      '-t', String(DURATION),
+      '-movflags', '+faststart',
+      file,
+    ]);
+    console.log(`Wrote out/film1-${s.id}.mp4`);
+  }
+
+  if (poster) {
+    // The poster is a frame from the beat that shows the saved board.
+    const i = beats.beats.findIndex((b) => b.id === 'saved');
+    const start = beats.beats[i].start;
+    const end = beats.beats[i + 1]?.start ?? DURATION;
+    const frame = Math.round((start + (end - start) * 0.875) * FPS);
+    const inputProps = {shapeId: '16x9'};
+    const composition = await selectComposition({serveUrl, id: 'film1-16x9', inputProps, ...browserOptions()});
+    const png = join(master, 'film1-poster-master.png');
+    await renderStill({composition, serveUrl, inputProps, frame, scale: 2, output: png, ...browserOptions()});
+    ffmpeg(['-y', '-i', png, '-vf', 'scale=1920:1080:flags=lanczos', '-q:v', '2', join(out, 'film1-poster.jpg')]);
+    console.log('Wrote out/film1-poster.jpg');
+  }
 }
-const all = targets.includes('all');
-const shapeList = shapes.filter((s) => all || targets.includes(s.id));
-const poster = all || targets.includes('poster');
 
-prepareMedia();
-mkdirSync(master, {recursive: true});
-const serveUrl = await makeBundle();
+async function renderFilm2(targets) {
+  const renditions = ['16x9', '1x1', '4x5', 'short-liveview', 'short-dax', 'short-shapes', 'store', 'site'];
+  if (targets.length === 0 || targets.some((t) => t !== 'all' && !renditions.includes(t))) {
+    console.error(`Name a rendition: ${renditions.join(', ')}, or all.`);
+    process.exit(1);
+  }
+  const wanted = targets.includes('all') ? renditions : targets;
+  // The store trailer and the site files come from the 16:9 master.
+  const compositionOf = (r) => (r === 'store' || r === 'site' ? 'film2-16x9' : `film2-${r}`);
+  const needed = [...new Set(wanted.map(compositionOf))];
 
-for (const s of shapeList) {
-  const inputProps = {shapeId: s.id};
-  const composition = await selectComposition({serveUrl, id: `film1-${s.id}`, inputProps, ...browserOptions()});
-  const masterFile = join(master, `film1-${s.id}-master.mp4`);
-  await renderMedia({
-    composition,
-    serveUrl,
-    inputProps,
-    codec: 'h264',
-    outputLocation: masterFile,
-    scale: 2,
-    crf: 12,
-    imageFormat: 'jpeg',
-    jpegQuality: 95,
-    pixelFormat: 'yuv420p',
-    // A silent track stands in for the voice until audio/film1-vo.mp3 exists.
-    enforceAudioTrack: true,
-    audioCodec: 'aac',
-    audioBitrate: '320k',
-    onProgress: progressLogger(`film1-${s.id} master`),
-    ...browserOptions(),
-  });
+  prepareMedia();
+  mkdirSync(master, {recursive: true});
+  const serveUrl = await makeBundle();
+
+  const masters = {};
+  for (const id of needed) {
+    const c = film2Compositions.find((x) => x.id === id);
+    const inputProps = {shapeId: c.shapeId, cutId: c.cutId};
+    const composition = await selectComposition({serveUrl, id, inputProps, ...browserOptions()});
+    masters[id] = join(master, `${id}-master.mp4`);
+    await renderMedia({
+      composition,
+      serveUrl,
+      inputProps,
+      codec: 'h264',
+      outputLocation: masters[id],
+      crf: 10,
+      imageFormat: 'png',
+      pixelFormat: 'yuv420p',
+      muted: true,
+      onProgress: progressLogger(`${id} master`),
+      ...browserOptions(),
+    });
+  }
+
+  const bed = join(root, 'audio', 'film2-bed.mp3');
+  const hasBed = existsSync(bed);
+  if (!hasBed) console.log('audio/film2-bed.mp3 is missing: the social files carry a silent track.');
+
+  for (const r of wanted) {
+    const id = compositionOf(r);
+    const c = film2Compositions.find((x) => x.id === id);
+    const seconds = cuts[c.cutId].seconds;
+    if (r === 'site') {
+      encodeSite(masters[id], seconds);
+      continue;
+    }
+    const name = r === 'store' ? 'film2-store-1920x1080.mp4' : `film2-${r}.mp4`;
+    encodeSocial(masters[id], join(out, name), seconds, c.cutId === 'film', r === 'store' ? 16 : 18, hasBed ? bed : null);
+    console.log(`Wrote out/${name}`);
+  }
+}
+
+// The music bed under a cut: the film takes the bed from its start, where it rises on
+// its own, and fades it over the end card; a short takes 12 seconds from the middle of
+// the bed, with a short fade at each end. The level is set so the mix averages -20 dB.
+function bedFilter(bed, seconds, fromStart) {
+  const offset = fromStart ? 0 : 14;
+  const fadeIn = fromStart ? 0 : 0.5;
+  const fadeOut = fromStart ? 2.5 : 1.5;
+  const shape = [
+    `atrim=start=${offset}:end=${offset + seconds}`,
+    'asetpts=PTS-STARTPTS',
+    ...(fadeIn ? [`afade=t=in:st=0:d=${fadeIn}`] : []),
+    `afade=t=out:st=${seconds - fadeOut}:d=${fadeOut}`,
+  ].join(',');
+  const gain = -20 - meanVolume(bed, shape);
+  return `${shape},volume=${gain.toFixed(2)}dB,alimiter=limit=0.9:level=disabled`;
+}
 
-  const file = join(out, `film1-${s.id}.mp4`);
+function encodeSocial(masterFile, file, seconds, fromStart, crf, bed) {
+  const audioIn = bed ? ['-i', bed] : ['-f', 'lavfi', '-t', String(seconds), '-i', 'anullsrc=r=48000:cl=stereo'];
+  const audioMap = bed ? ['-filter_complex', `[1:a]${bedFilter(bed, seconds, fromStart)}[a]`, '-map', '0:v', '-map', '[a]'] : ['-map', '0:v', '-map', '1:a'];
   ffmpeg([
     '-y',
     '-i', masterFile,
-    // The master is flagged full range; the platforms expect limited range.
-    '-vf', `scale=${s.width}:${s.height}:flags=lanczos:out_range=tv,format=yuv420p`,
+    ...audioIn,
+    ...audioMap,
+    '-vf', 'scale=in_range=auto:out_range=tv,format=yuv420p',
     '-color_range', 'tv',
     '-c:v', 'libx264',
     '-profile:v', 'high',
     '-preset', 'slow',
-    '-crf', '20',
+    '-crf', String(crf),
     '-pix_fmt', 'yuv420p',
     '-r', String(FPS),
     '-c:a', 'aac',
     '-b:a', '128k',
-    '-t', String(DURATION),
+    '-ar', '48000',
+    '-t', String(seconds),
     '-movflags', '+faststart',
     file,
   ]);
-  console.log(`Wrote out/film1-${s.id}.mp4`);
 }
 
-if (poster) {
-  // The poster is a frame from the beat that shows the saved board.
-  const i = beats.beats.findIndex((b) => b.id === 'saved');
-  const start = beats.beats[i].start;
-  const end = beats.beats[i + 1]?.start ?? DURATION;
-  const frame = Math.round((start + (end - start) * 0.875) * FPS);
-  const inputProps = {shapeId: '16x9'};
-  const composition = await selectComposition({serveUrl, id: 'film1-16x9', inputProps, ...browserOptions()});
-  const png = join(master, 'film1-poster-master.png');
-  await renderStill({composition, serveUrl, inputProps, frame, scale: 2, output: png, ...browserOptions()});
-  ffmpeg(['-y', '-i', png, '-vf', 'scale=1920:1080:flags=lanczos', '-q:v', '2', join(out, 'film1-poster.jpg')]);
-  console.log('Wrote out/film1-poster.jpg');
+// The commands in docs/teaser/shot-script.md. The site file loops, so the end card fades
+// to paper over the last half second and the restart cuts to the white board. The camera
+// is always moving, so every frame differs from the last; the CRFs are higher than the
+// 42-second cut's to keep each file near 3.5 MB.
+function encodeSite(masterFile, seconds) {
+  const site = join(root, '..', '..', 'site');
+  const fade = `fade=t=out:st=${seconds - 0.5}:d=0.5:color=0xF7F6F2`;
+  ffmpeg(['-y', '-i', masterFile, '-vf', `scale=1920:-2:flags=lanczos,${fade}`, '-c:v', 'libsvtav1', '-crf', '46', '-preset', '6', '-movflags', '+faststart', '-an', join(site, 'teaser-av1.mp4')]);
+  ffmpeg(['-y', '-i', masterFile, '-vf', `scale=1920:-2:flags=lanczos,${fade}`, '-c:v', 'libx264', '-crf', '31', '-preset', 'veryslow', '-pix_fmt', 'yuv420p', '-movflags', '+faststart', '-an', join(site, 'teaser-h264.mp4')]);
+  // The poster is the whole board, from the 41–47 s beat.
+  ffmpeg(['-y', '-ss', '46.0', '-i', masterFile, '-frames:v', '1', '-vf', 'scale=1920:-2:flags=lanczos', '-q:v', '3', join(site, 'teaser-poster.jpg')]);
+  console.log('Wrote site/teaser-av1.mp4, site/teaser-h264.mp4, and site/teaser-poster.jpg');
 }
diff --git a/tools/films/scripts/stills.mjs b/tools/films/scripts/stills.mjs
index d0a3f8f..efea78f 100644
--- a/tools/films/scripts/stills.mjs
+++ b/tools/films/scripts/stills.mjs
@@ -1,22 +1,42 @@
-// Renders review stills of every shape at 2, 6, 10, 14, 20, 25, and 29 seconds, one in
-// each beat, and the font check, into out/stills/.
-//   node scripts/stills.mjs            every shape
-//   node scripts/stills.mjs 9x16 1x1   the shapes named
-//   node scripts/stills.mjs --at=18.2  other times, in seconds
+// Renders review stills and the font check into out/stills/.
+//   node scripts/stills.mjs                 film 1, every shape, one still in each beat
+//   node scripts/stills.mjs 9x16 1x1        film 1, the shapes named
+//   node scripts/stills.mjs film2           film 2, every composition, every 5 seconds
+//   node scripts/stills.mjs film2 16x9 short-dax
+//   ... --at=18.2,19                        other times, in seconds
 import {mkdirSync} from 'node:fs';
 import {join} from 'node:path';
 import {renderStill, selectComposition} from '@remotion/renderer';
+import {film2Compositions} from '../src/film2/compositions.ts';
+import {cuts} from '../src/film2/cuts.ts';
 import {shapes} from '../src/layout.ts';
 import {browserOptions, makeBundle, out} from './lib.mjs';
 import {prepareMedia} from './prepare-media.mjs';
 
 const FPS = 30;
-const args = process.argv.slice(2);
+let args = process.argv.slice(2);
+const film2 = args[0] === 'film2';
+if (film2) args = args.slice(1);
 const at = args.find((a) => a.startsWith('--at='));
-const SECONDS = at ? at.slice(5).split(',').map(Number) : [2, 6, 10, 14, 20, 25, 29];
-
+const times = at ? at.slice(5).split(',').map(Number) : null;
 const wanted = args.filter((a) => !a.startsWith('--'));
-const list = wanted.length ? shapes.filter((s) => wanted.includes(s.id)) : shapes;
+
+// Each item: a composition, its props, and the times to render.
+const jobs = film2
+  ? film2Compositions
+      .filter((c) => wanted.length === 0 || wanted.includes(c.id.replace(/^film2-/, '')))
+      .map((c) => {
+        const seconds = cuts[c.cutId].seconds;
+        const every5 = [];
+        for (let s = 0; s < seconds; s += 5) every5.push(s);
+        every5.push(seconds - 1 / FPS);
+        return {id: c.id, inputProps: {shapeId: c.shapeId, cutId: c.cutId}, seconds: times ?? every5};
+      })
+  : (wanted.length ? shapes.filter((s) => wanted.includes(s.id)) : shapes).map((s) => ({
+      id: `film1-${s.id}`,
+      inputProps: {shapeId: s.id},
+      seconds: times ?? [2, 6, 10, 14, 20, 25, 29],
+    }));
 
 prepareMedia();
 const serveUrl = await makeBundle();
@@ -27,16 +47,16 @@ const fontCheck = await selectComposition({serveUrl, id: 'font-check', ...browse
 await renderStill({composition: fontCheck, serveUrl, output: join(dir, 'font-check.png'), ...browserOptions()});
 console.log('out/stills/font-check.png');
 
-for (const s of list) {
-  const inputProps = {shapeId: s.id};
-  const composition = await selectComposition({serveUrl, id: `film1-${s.id}`, inputProps, ...browserOptions()});
-  for (const sec of SECONDS) {
-    const name = `film1-${s.id}-${String(sec).padStart(2, '0')}s.png`;
+for (const job of jobs) {
+  const composition = await selectComposition({serveUrl, id: job.id, inputProps: job.inputProps, ...browserOptions()});
+  for (const sec of job.seconds) {
+    const label = Number.isInteger(sec) ? String(sec).padStart(2, '0') : sec.toFixed(2).padStart(5, '0');
+    const name = `${job.id}-${label}s.png`;
     await renderStill({
       composition,
       serveUrl,
-      inputProps,
-      frame: Math.round(sec * FPS),
+      inputProps: job.inputProps,
+      frame: Math.min(composition.durationInFrames - 1, Math.round(sec * FPS)),
       output: join(dir, name),
       ...browserOptions(),
     });
diff --git a/tools/films/src/Root.tsx b/tools/films/src/Root.tsx
index 32835a7..0c3bedf 100644
--- a/tools/films/src/Root.tsx
+++ b/tools/films/src/Root.tsx
@@ -1,10 +1,14 @@
 import React from 'react';
 import {Composition, Folder, Still} from 'remotion';
 import {DURATION_SECONDS, FPS, Film1} from './film1/Film1';
+import {FPS as FPS2, Film2} from './film2/Film2';
+import {film2Compositions} from './film2/compositions';
+import {cuts} from './film2/cuts';
 import {FontCheck} from './FontCheck';
 import {shapes} from './layout';
 
-// One composition per shape, all rendering the same film with the layout of its shape.
+// Film 1 has one composition per shape, all rendering the same film with the layout of
+// its shape. Film 2 has the film in three shapes and three portrait shorts.
 export const Root: React.FC = () => (
   <>
     <Folder name="film1-export-before-16-october">
@@ -21,6 +25,23 @@ export const Root: React.FC = () => (
         />
       ))}
     </Folder>
+    <Folder name="film2-one-board">
+      {film2Compositions.map((c) => {
+        const shape = shapes.find((s) => s.id === c.shapeId)!;
+        return (
+          <Composition
+            key={c.id}
+            id={c.id}
+            component={Film2}
+            width={shape.width}
+            height={shape.height}
+            fps={FPS2}
+            durationInFrames={Math.round(cuts[c.cutId].seconds * FPS2)}
+            defaultProps={{shapeId: c.shapeId, cutId: c.cutId}}
+          />
+        );
+      })}
+    </Folder>
     <Still id="font-check" component={FontCheck} width={1920} height={1080} />
   </>
 );
diff --git a/tools/films/src/brand.ts b/tools/films/src/brand.ts
index 21b3056..aac0c45 100644
--- a/tools/films/src/brand.ts
+++ b/tools/films/src/brand.ts
@@ -1,4 +1,4 @@
-import {Easing} from 'remotion';
+import {Easing, interpolate} from 'remotion';
 
 // The campaign colors, as used by site/hero-launch-card.svg and the app icon.
 export const color = {
@@ -24,3 +24,7 @@ export const fontFamily = '"Segoe UI Variable Display", "Segoe UI", sans-serif';
 
 // Every transition eases in and out, with no overshoot.
 export const ease = Easing.bezier(0.45, 0, 0.55, 1);
+
+// Eased progress from 0 to 1 over [start, start + length], in seconds.
+export const progress = (t: number, start: number, length: number) =>
+  interpolate(t, [start, start + length], [0, 1], {easing: ease, extrapolateLeft: 'clamp', extrapolateRight: 'clamp'});
diff --git a/tools/films/src/components/EndCard.tsx b/tools/films/src/components/EndCard.tsx
new file mode 100644
index 0000000..c32ae78
--- /dev/null
+++ b/tools/films/src/components/EndCard.tsx
@@ -0,0 +1,98 @@
+import React from 'react';
+import {color, navyGradient, progress} from '../brand';
+import type {Layout} from '../layout';
+import {AppIcon, SqlbiWordmark} from './Artwork';
+
+// The end card, on paper, centred in the safe area: the icon, the name with a pen
+// underline, "Free and open source", the address, and optionally an install command and
+// the SQLBI wordmark. `t` is seconds since the card began; each line rises into place
+// in turn.
+export const EndCard: React.FC<{
+  L: Layout;
+  t: number;
+  address: React.ReactNode;
+  command?: string;
+  wordmark?: boolean;
+}> = ({L, t, address, command, wordmark = false}) => {
+  const k = L.landscape ? 1 : L.width === L.height ? 0.7 : 0.78;
+  const s = L.safe;
+  const item = (delay: number): React.CSSProperties => {
+    const p = progress(t, 0.25 + delay, 0.4);
+    return {opacity: p, transform: `translateY(${(1 - p) * 18 * k}px)`};
+  };
+  const underline = progress(t, 0.8, 0.5);
+  const nameSize = 112 * k;
+  const underlineW = nameSize * 7.4;
+
+  return (
+    <div
+      style={{
+        position: 'absolute',
+        left: s.x,
+        top: s.y,
+        width: s.w,
+        height: s.h,
+        display: 'flex',
+        flexDirection: 'column',
+        alignItems: 'center',
+        justifyContent: 'center',
+        textAlign: 'center',
+        color: color.navy,
+      }}
+    >
+      <div style={item(0)}>
+        <AppIcon size={196 * k} />
+      </div>
+      <div style={{...item(0.1), marginTop: 30 * k, position: 'relative'}}>
+        <div style={{fontWeight: 700, fontSize: nameSize, lineHeight: 1.1, letterSpacing: '-0.02em', whiteSpace: 'nowrap'}}>
+          SQLBI Whiteboard
+        </div>
+        <svg
+          width={underlineW}
+          height={(underlineW * 26) / 360}
+          viewBox="0 0 360 26"
+          style={{position: 'absolute', left: '50%', marginLeft: -underlineW / 2, top: nameSize * 1.08, overflow: 'visible'}}
+        >
+          <path
+            d="M6 14c88-7 178-9 252-6 32 1 62 4 90 8"
+            stroke={color.pen}
+            strokeWidth="3.6"
+            fill="none"
+            strokeLinecap="round"
+            pathLength={1}
+            strokeDasharray="1 1"
+            strokeDashoffset={1 - underline}
+            opacity={underline > 0 ? 0.92 : 0}
+          />
+        </svg>
+      </div>
+      <div style={{...item(0.2), marginTop: 44 * k, fontWeight: 600, fontSize: 60 * k, lineHeight: 1.2}}>Free and open source</div>
+      <div style={{...item(0.3), marginTop: 30 * k, fontWeight: 600, fontSize: 56 * k, lineHeight: 1.22, color: color.navy}}>
+        {address}
+      </div>
+      {command ? (
+        <div
+          style={{
+            ...item(0.4),
+            marginTop: 34 * k,
+            padding: `${14 * k}px ${30 * k}px`,
+            borderRadius: 14 * k,
+            background: navyGradient,
+            color: color.paper,
+            fontWeight: 600,
+            fontSize: 48 * k,
+            lineHeight: 1.2,
+            whiteSpace: 'nowrap',
+          }}
+        >
+          {command}
+        </div>
+      ) : null}
+      {wordmark ? (
+        <div style={{...item(0.5), marginTop: 46 * k}}>
+          <SqlbiWordmark height={52 * k} />
+        </div>
+      ) : null}
+    </div>
+  );
+};
diff --git a/tools/films/src/film1/Film1.tsx b/tools/films/src/film1/Film1.tsx
index a58d5bf..37959ee 100644
--- a/tools/films/src/film1/Film1.tsx
+++ b/tools/films/src/film1/Film1.tsx
@@ -1,9 +1,10 @@
 import React from 'react';
 import {AbsoluteFill, Audio, interpolate, useCurrentFrame, useVideoConfig} from 'remotion';
-import {color, ease, fontFamily, navyGradient} from '../brand';
-import {AppIcon, SqlbiWindow, SqlbiWordmark, ZipFile} from '../components/Artwork';
+import {color, fontFamily, navyGradient, progress} from '../brand';
+import {SqlbiWindow, ZipFile} from '../components/Artwork';
 import {Calendar} from '../components/Calendar';
 import {CaptureView} from '../components/CaptureView';
+import {EndCard} from '../components/EndCard';
 import {WindowFrame} from '../components/WindowFrame';
 import {layoutFor, shapes, type Layout, type Rect} from '../layout';
 import {mediaFile} from '../media';
@@ -42,10 +43,6 @@ const RETIREMENT_QUOTE = '“a retirement experience instead of opening”';
 
 const BED_GAIN = Math.pow(10, -22 / 20);
 
-// Eased progress from 0 to 1 over [start, start + length], in seconds.
-const progress = (t: number, start: number, length: number) =>
-  interpolate(t, [start, start + length], [0, 1], {easing: ease, extrapolateLeft: 'clamp', extrapolateRight: 'clamp'});
-
 const lerp = (a: number, b: number, p: number) => a + (b - a) * p;
 const lerpRect = (a: Rect, b: Rect, p: number): Rect => ({
   x: lerp(a.x, b.x, p),
@@ -98,7 +95,7 @@ export const Film1: React.FC<{shapeId: string}> = ({shapeId}) => {
         <SqlbiScene L={L} t={t} />
       </AbsoluteFill>
 
-      {t >= end.start ? <EndCard L={L} t={t - end.start} /> : null}
+      {t >= end.start ? <Film1EndCard L={L} t={t - end.start} /> : null}
     </AbsoluteFill>
   );
 };
@@ -301,92 +298,22 @@ const SqlbiScene: React.FC<{L: Layout; t: number}> = ({L, t}) => {
 };
 
 // The end card, on paper. `t` is seconds since the card began.
-const EndCard: React.FC<{L: Layout; t: number}> = ({L, t}) => {
-  const k = L.landscape ? 1 : shapesScale(L);
-  const s = L.safe;
-  const item = (delay: number): React.CSSProperties => {
-    const p = progress(t, 0.25 + delay, 0.4);
-    return {opacity: p, transform: `translateY(${(1 - p) * 18 * k}px)`};
-  };
-  const underline = progress(t, 0.8, 0.5);
-  const nameSize = 112 * k;
-  const underlineW = nameSize * 7.4;
-
-  return (
-    <div
-      style={{
-        position: 'absolute',
-        left: s.x,
-        top: s.y,
-        width: s.w,
-        height: s.h,
-        display: 'flex',
-        flexDirection: 'column',
-        alignItems: 'center',
-        justifyContent: 'center',
-        textAlign: 'center',
-        color: color.navy,
-      }}
-    >
-      <div style={item(0)}>
-        <AppIcon size={196 * k} />
-      </div>
-      <div style={{...item(0.1), marginTop: 30 * k, position: 'relative'}}>
-        <div style={{fontWeight: 700, fontSize: nameSize, lineHeight: 1.1, letterSpacing: '-0.02em', whiteSpace: 'nowrap'}}>
-          SQLBI Whiteboard
-        </div>
-        <svg
-          width={underlineW}
-          height={(underlineW * 26) / 360}
-          viewBox="0 0 360 26"
-          style={{position: 'absolute', left: '50%', marginLeft: -underlineW / 2, top: nameSize * 1.08, overflow: 'visible'}}
-        >
-          <path
-            d="M6 14c88-7 178-9 252-6 32 1 62 4 90 8"
-            stroke={color.pen}
-            strokeWidth="3.6"
-            fill="none"
-            strokeLinecap="round"
-            pathLength={1}
-            strokeDasharray="1 1"
-            strokeDashoffset={1 - underline}
-            opacity={underline > 0 ? 0.92 : 0}
-          />
-        </svg>
-      </div>
-      <div style={{...item(0.2), marginTop: 44 * k, fontWeight: 600, fontSize: 60 * k, lineHeight: 1.2}}>Free and open source</div>
-      <div style={{...item(0.3), marginTop: 30 * k, fontWeight: 600, fontSize: 56 * k, lineHeight: 1.22, color: color.navy}}>
-        {L.narrow ? (
-          <>
-            whiteboard.sqlbi.com/
-            <br />
-            export-microsoft-whiteboard.html
-          </>
-        ) : (
-          'whiteboard.sqlbi.com/export-microsoft-whiteboard.html'
-        )}
-      </div>
-      <div
-        style={{
-          ...item(0.4),
-          marginTop: 34 * k,
-          padding: `${14 * k}px ${30 * k}px`,
-          borderRadius: 14 * k,
-          background: navyGradient,
-          color: color.paper,
-          fontWeight: 600,
-          fontSize: 48 * k,
-          lineHeight: 1.2,
-          whiteSpace: 'nowrap',
-        }}
-      >
-        winget install SQLBI.Whiteboard
-      </div>
-      <div style={{...item(0.5), marginTop: 46 * k}}>
-        <SqlbiWordmark height={52 * k} />
-      </div>
-    </div>
-  );
-};
-
-const shapesScale = (L: Layout) => (L.width === L.height ? 0.7 : 0.78);
+const Film1EndCard: React.FC<{L: Layout; t: number}> = ({L, t}) => (
+  <EndCard
+    L={L}
+    t={t}
+    address={
+      L.narrow ? (
+        <>
+          whiteboard.sqlbi.com/
+          <br />
+          export-microsoft-whiteboard.html
+        </>
+      ) : (
+        'whiteboard.sqlbi.com/export-microsoft-whiteboard.html'
+      )
+    }
+    command="winget install SQLBI.Whiteboard"
+    wordmark
+  />
+);
diff --git a/tools/films/src/film2/Film2.tsx b/tools/films/src/film2/Film2.tsx
new file mode 100644
index 0000000..c81e2b5
--- /dev/null
+++ b/tools/films/src/film2/Film2.tsx
@@ -0,0 +1,193 @@
+import React from 'react';
+import {AbsoluteFill, useCurrentFrame, useVideoConfig} from 'remotion';
+import {color, ease, fontFamily, progress} from '../brand';
+import {CaptureView} from '../components/CaptureView';
+import {EndCard} from '../components/EndCard';
+import {WindowFrame} from '../components/WindowFrame';
+import {layoutFor, shapes, type Rect} from '../layout';
+import {boardFor, DRIFT, LINE_HEIGHT, type Board, type Camera, type Caption, type Station} from './board';
+import {captures} from './captures';
+import {CLOSING, captions, cuts, type Cut, type CutId, type Segment} from './cuts';
+
+export const FPS = 30;
+
+const lerp = (a: number, b: number, p: number) => a + (b - a) * p;
+const lerpLog = (a: number, b: number, p: number) => Math.exp(lerp(Math.log(a), Math.log(b), p));
+
+const arrive = (s: Station): Camera => s.camera;
+const depart = (s: Station): Camera => ({...s.camera, z: s.camera.z * (1 + DRIFT)});
+
+const segmentCamera = (board: Board, seg: Segment, t: number): Camera => {
+  const p = ease(Math.min(1, Math.max(0, (t - seg.t0) / (seg.t1 - seg.t0))));
+  switch (seg.kind) {
+    case 'hold': {
+      const s = board.stations[seg.at];
+      return {...s.camera, z: lerpLog(arrive(s).z * (seg.zoomFrom ?? 1), depart(s).z, p)};
+    }
+    case 'move': {
+      const a = depart(board.stations[seg.from]);
+      const b = arrive(board.stations[seg.to]);
+      return {
+        x: lerp(a.x, b.x, p),
+        y: lerp(a.y, b.y, p),
+        z: lerpLog(a.z, b.z, p) * (1 - seg.dip * Math.sin(Math.PI * p)),
+      };
+    }
+    case 'pull': {
+      // The zoom changes at an even rate, and the centre moves with the visible width,
+      // so the board widens around a point that stays where it is in the frame.
+      const a = depart(board.stations[seg.from]);
+      const b = board.whole;
+      const z = lerpLog(a.z, b.z, p);
+      const f = (1 / z - 1 / a.z) / (1 / b.z - 1 / a.z);
+      return {x: lerp(a.x, b.x, f), y: lerp(a.y, b.y, f), z};
+    }
+    case 'whole':
+      return {...board.whole, z: board.whole.z * lerp(1, 1.01, p)};
+  }
+};
+
+export const cameraAt = (board: Board, cut: Cut, t: number): Camera => {
+  const segs = cut.camera;
+  const seg = segs.find((s) => t < s.t1) ?? segs[segs.length - 1];
+  return segmentCamera(board, seg, t);
+};
+
+export const Film2: React.FC<{shapeId: string; cutId: CutId}> = ({shapeId, cutId}) => {
+  const frame = useCurrentFrame();
+  const {fps, width, height} = useVideoConfig();
+  const shape = shapes.find((s) => s.id === shapeId);
+  if (!shape) throw new Error(`Unknown shape ${shapeId}`);
+  const cut = cuts[cutId];
+  const board = boardFor(shape);
+  const t = frame / fps;
+  const cam = cameraAt(board, cut, t);
+
+  // Only what overlaps the frame is drawn, so captures off screen cost nothing.
+  const inFrame = (r: Rect, pad = 0.05) => {
+    const x = (r.x - cam.x) * cam.z + width / 2;
+    const y = (r.y - cam.y) * cam.z + height / 2;
+    const w = r.w * cam.z;
+    const h = r.h * cam.z;
+    const mx = width * pad;
+    const my = height * pad;
+    return x < width + mx && x + w > -mx && y < height + my && y + h > -my;
+  };
+
+  const boardOpacity = 1 - progress(t, cut.endCard, 0.5);
+
+  return (
+    <AbsoluteFill style={{background: color.paper, fontFamily, overflow: 'hidden'}}>
+      {boardOpacity > 0 ? (
+        <div
+          style={{
+            position: 'absolute',
+            left: 0,
+            top: 0,
+            transformOrigin: '0 0',
+            transform: `translate(${width / 2}px, ${height / 2}px) scale(${cam.z}) translate(${-cam.x}px, ${-cam.y}px)`,
+            opacity: boardOpacity,
+          }}
+        >
+          {Object.values(board.stations).map((s) =>
+            inFrame(s.window) ? <StationWindow key={s.id} station={s} cut={cut} t={t} fps={fps} /> : null,
+          )}
+          {Object.values(board.stations).map((s) =>
+            captions[s.id] && inFrame(s.caption.rect) ? (
+              <CaptionText key={`${s.id}-caption`} caption={s.caption} text={captions[s.id]} underline={s.id === 'D1'} />
+            ) : null,
+          )}
+          {cut.closing && inFrame(board.closing.rect) ? (
+            <ClosingLine caption={board.closing} opacity={closingOpacity(cut, t)} />
+          ) : null}
+        </div>
+      ) : null}
+      {t >= cut.endCard ? <EndCard L={layoutFor(shape)} t={t - cut.endCard} address="whiteboard.sqlbi.com" /> : null}
+    </AbsoluteFill>
+  );
+};
+
+// A capture in its window. It holds its first frame until its play starts and its last
+// frame after it ends. A short plays only its own station; the others never enter its
+// frame, and hold their first frame.
+const StationWindow: React.FC<{station: Station; cut: Cut; t: number; fps: number}> = ({station, cut, t, fps}) => {
+  const base = captures[station.id];
+  const play = cut.plays[station.id] ?? {start: Infinity, from: 0, rate: 1};
+  const capture = {...base, from: play.from, rate: play.rate};
+  const end = play.start + (base.seconds - play.from) / play.rate;
+  const {w, h} = station.window;
+
+  let view: React.ReactNode;
+  if (t >= end) {
+    view = <CaptureView capture={capture} startFrame={0} still holdAt={base.seconds} width={w} height={h} />;
+  } else if (t < play.start) {
+    view = <CaptureView capture={capture} startFrame={0} still holdAt={play.from} width={w} height={h} />;
+  } else {
+    view = <CaptureView capture={capture} startFrame={Math.round(play.start * fps)} width={w} height={h} />;
+  }
+  return <WindowFrame rect={station.window}>{view}</WindowFrame>;
+};
+
+const CaptionText: React.FC<{caption: Caption; text: string; underline: boolean}> = ({caption, text, underline}) => {
+  const {rect, size} = caption;
+  const underlineW = size * 7.4;
+  return (
+    <div
+      style={{
+        position: 'absolute',
+        left: rect.x,
+        top: rect.y,
+        width: rect.w,
+        color: color.navy,
+        fontWeight: 700,
+        fontSize: size,
+        lineHeight: LINE_HEIGHT,
+        letterSpacing: '-0.01em',
+        textWrap: 'balance',
+      }}
+    >
+      {text}
+      {underline ? (
+        <svg
+          width={underlineW}
+          height={(underlineW * 26) / 360}
+          viewBox="0 0 360 26"
+          style={{position: 'absolute', left: -size * 0.02, top: size * 1.06, overflow: 'visible'}}
+        >
+          <path d="M6 14c88-7 178-9 252-6 32 1 62 4 90 8" stroke={color.pen} strokeWidth="3.6" fill="none" strokeLinecap="round" opacity={0.92} />
+        </svg>
+      ) : null}
+    </div>
+  );
+};
+
+// The closing line appears in the last second of the pull back, once it is inside the
+// frame, so a move that passes near it earlier does not show it.
+const closingOpacity = (cut: Cut, t: number) => {
+  const pull = cut.camera.find((s) => s.kind === 'pull');
+  return pull ? progress(t, pull.t1 - 1, 1) : 1;
+};
+
+const ClosingLine: React.FC<{caption: Caption; opacity: number}> = ({caption, opacity}) => {
+  const {rect, size} = caption;
+  return (
+    <div
+      style={{
+        opacity,
+        position: 'absolute',
+        left: rect.x,
+        top: rect.y,
+        width: rect.w,
+        textAlign: 'center',
+        color: color.navy,
+        fontWeight: 700,
+        fontSize: size,
+        lineHeight: 1.2,
+        letterSpacing: '-0.01em',
+        whiteSpace: 'nowrap',
+      }}
+    >
+      {CLOSING}
+    </div>
+  );
+};
diff --git a/tools/films/src/film2/board.ts b/tools/films/src/film2/board.ts
new file mode 100644
index 0000000..6454e09
--- /dev/null
+++ b/tools/films/src/film2/board.ts
@@ -0,0 +1,173 @@
+// The board of film 2 and the camera that moves across it.
+//
+// The board is one plane measured in board units, where a 1920 x 1080 capture is 1920 x
+// 1080 units. Each station is a capture in a window with its caption on the board below
+// it. The camera is a centre on the board and a zoom, the output pixels per board unit;
+// it never goes above 1, so no capture is enlarged past its own size.
+//
+// The board is laid out once per shape: each shape has its own station framing, caption
+// size, and gaps, chosen so that at a station the caption sits inside the safe area of
+// that shape and no neighbouring window shows at the edge of the frame.
+
+import type {Rect, Shape} from '../layout';
+import type {StationId} from './captures';
+
+export const WINDOW = {w: 1920, h: 1080};
+
+// The slow push-in while the camera rests on a station, as a fraction of the zoom.
+export const DRIFT = 0.025;
+
+export type Camera = {x: number; y: number; z: number};
+
+export type Caption = {rect: Rect; size: number};
+
+export type Station = {
+  id: StationId;
+  window: Rect;
+  caption: Caption;
+  // The camera on arrival; it pushes in by DRIFT before it leaves.
+  camera: Camera;
+};
+
+export type Board = {
+  shape: Shape;
+  stations: Record<StationId, Station>;
+  // The closing line below the stations, and the camera that frames the whole board.
+  closing: Caption;
+  whole: Camera;
+  bounds: Rect;
+};
+
+// Where each station sits, in columns and rows. The camera visits them in the order of
+// the beats: right, down, left past D7, up, then down and left to D6.
+const grid: Record<StationId, [number, number]> = {
+  D1: [0, 0],
+  D2: [1, 0],
+  D3: [1, 1],
+  D7: [0, 1],
+  D4: [-1, 1],
+  D5: [-1, 0],
+  D6: [-2, 0.5],
+};
+
+type Spec = {
+  // Caption size in output pixels at a station, its line height, and the lines it may use.
+  captionPx: number;
+  captionLines: number;
+  // Gap between the window and its caption, in output pixels.
+  gapPx: number;
+  // The window fits the safe area, or is this many times the width of the frame and runs
+  // off both sides (portrait shorts, where a window that fits would be too small to read).
+  windowSpan: 'safe' | number;
+  // Size of the closing line in output pixels when the whole board is in frame.
+  closingPx: number;
+};
+
+export const LINE_HEIGHT = 1.12;
+
+const specs: Record<string, Spec> = {
+  '16x9': {captionPx: 50, captionLines: 2, gapPx: 30, windowSpan: 'safe', closingPx: 64},
+  '1x1': {captionPx: 46, captionLines: 3, gapPx: 28, windowSpan: 'safe', closingPx: 50},
+  '4x5': {captionPx: 50, captionLines: 3, gapPx: 30, windowSpan: 'safe', closingPx: 54},
+  '9x16': {captionPx: 64, captionLines: 4, gapPx: 40, windowSpan: 1.25, closingPx: 60},
+};
+
+// Where a window wider than the frame is cropped: 0.5 crops both sides equally, a lower
+// value keeps more of the left. The table in D2, the measure in D3, and the moved shape
+// in D4 sit against the left edge; the toolbar on the right gives way.
+const focus: Partial<Record<StationId, number>> = {D2: 0.2, D3: 0.15, D4: 0.2};
+
+// The safe area shrunk about the centre of the frame, so that what fits inside it stays
+// inside the safe area through the push-in.
+const innerSafe = (shape: Shape, drift: number): Rect => {
+  const cx = shape.width / 2;
+  const cy = shape.height / 2;
+  const k = 1 / (1 + drift);
+  const {x, y, w, h} = shape.safe;
+  return {x: cx + (x - cx) * k, y: cy + (y - cy) * k, w: w * k, h: h * k};
+};
+
+export const boardFor = (shape: Shape): Board => {
+  const spec = specs[shape.id];
+  if (!spec) throw new Error(`Film 2 has no board for shape ${shape.id}`);
+  const inner = innerSafe(shape, DRIFT);
+  const captionH = spec.captionPx * LINE_HEIGHT * spec.captionLines;
+
+  // Station framing in output pixels: the window, then the caption below it, centred
+  // vertically in the inner safe area.
+  let z: number;
+  let capX: number;
+  let capW: number;
+  if (spec.windowSpan === 'safe') {
+    z = Math.min(inner.w / WINDOW.w, (inner.h - spec.gapPx - captionH) / WINDOW.h);
+    capX = Math.max(inner.x, (shape.width - WINDOW.w * z) / 2);
+    capW = Math.min(WINDOW.w * z, inner.w);
+  } else {
+    z = (shape.width * spec.windowSpan) / WINDOW.w;
+    capX = inner.x;
+    capW = inner.w;
+  }
+  const winXFor = (id: StationId) => (shape.width - WINDOW.w * z) * (spec.windowSpan === 'safe' ? 0.5 : (focus[id] ?? 0.5));
+  const winX = winXFor('D1');
+  const blockH = WINDOW.h * z + spec.gapPx + captionH;
+  const winY = inner.y + (inner.h - blockH) / 2;
+  const capY = winY + WINDOW.h * z + spec.gapPx;
+
+  // Gaps between stations, in board units, wide enough that no neighbour shows in the
+  // frame at a station: what the frame shows beyond the window and caption, plus a margin
+  // that covers the shorts, which start 10 % further back.
+  const margin = 320;
+  // A window wider than the frame covers it from side to side, so only the vertical gap
+  // matters there.
+  const gapX = Math.max(560, winX / z + margin, (shape.width - winX - WINDOW.w * z) / z + margin);
+  const stationH = WINDOW.h + (spec.gapPx + captionH) / z;
+  const gapY = Math.max(420, winY / z + margin, (shape.height - capY - captionH) / z + margin);
+  const pitchX = WINDOW.w + gapX;
+  const pitchY = stationH + gapY;
+
+  const stations = {} as Record<StationId, Station>;
+  for (const id of Object.keys(grid) as StationId[]) {
+    const [col, row] = grid[id];
+    const window: Rect = {x: col * pitchX, y: row * pitchY, w: WINDOW.w, h: WINDOW.h};
+    const winX = winXFor(id);
+    const caption: Caption = {
+      rect: {
+        x: window.x + (capX - winX) / z,
+        y: window.y + (capY - winY) / z,
+        w: capW / z,
+        h: captionH / z,
+      },
+      size: spec.captionPx / z,
+    };
+    // The board point at the centre of the frame when the window sits at (winX, winY).
+    const camera: Camera = {
+      x: window.x + (shape.width / 2 - winX) / z,
+      y: window.y + (shape.height / 2 - winY) / z,
+      z,
+    };
+    stations[id] = {id, window, caption, camera};
+  }
+
+  // The stations' extent: windows and captions.
+  const all = Object.values(stations);
+  const left = Math.min(...all.map((s) => s.window.x));
+  const right = Math.max(...all.map((s) => s.window.x + s.window.w));
+  const top = Math.min(...all.map((s) => s.window.y));
+  const bottom = Math.max(...all.map((s) => s.caption.rect.y + s.caption.rect.h));
+  const gridW = right - left;
+  const gridH = bottom - top;
+
+  // The closing line sits one gap below the stations and is sized for the whole-board
+  // framing, which in turn has to make room for it: zW * (gridH + gapY) + closing = inner.h.
+  const wholeInner = innerSafe(shape, 0.01);
+  const closingH = spec.closingPx * 1.2;
+  const zW = Math.min(wholeInner.w / gridW, (wholeInner.h - closingH) / (gridH + gapY));
+  const closing: Caption = {
+    rect: {x: left, y: bottom + gapY, w: gridW, h: closingH / zW},
+    size: spec.closingPx / zW,
+  };
+  const bounds: Rect = {x: left, y: top, w: gridW, h: gridH + gapY + closingH / zW};
+  const whole: Camera = {x: left + gridW / 2, y: top + bounds.h / 2, z: zW};
+
+  return {shape, stations, closing, whole, bounds};
+};
diff --git a/tools/films/src/film2/captures.ts b/tools/films/src/film2/captures.ts
new file mode 100644
index 0000000..130fb2c
--- /dev/null
+++ b/tools/films/src/film2/captures.ts
@@ -0,0 +1,43 @@
+import type {Capture} from '../film1/captures';
+
+// The seven captures of film 2, by the file names in README.md. All are 30 fps; D1 is
+// 3840 x 2160 and the others 1920 x 1080. Each sits on the board at 1920 x 1080 board
+// units, so D1 is shown at half its size and the others at their own size, and the camera
+// never zooms past 1, so no capture is ever enlarged.
+//
+// `seconds` is the length of the video track, read with ffprobe; a trim must end inside
+// it. `from` and `rate` here are the defaults; each cut in film.ts sets its own. Times
+// in the comments are seconds of the capture, read from frame sheets of the recordings
+// of 10 October 2026.
+
+export type StationId = 'D1' | 'D2' | 'D3' | 'D4' | 'D5' | 'D6' | 'D7';
+
+const capture = (id: StationId, file: string, seconds: number, description: string): Capture => ({
+  id,
+  file,
+  seconds,
+  description,
+  from: 0,
+  rate: 1,
+  callouts: [],
+});
+
+export const captures: Record<StationId, Capture> = {
+  // A dot at 0.1 s; three boxes by 5.8 s, the two connectors at 6.3 and 7.0 s.
+  D1: capture('D1', 'ink-diagram.mp4', 8.566, 'The pen draws a diagram; the pressure shows in the stroke.'),
+  // View at 0.5 s, the window picker from 2 s, the Power BI window on the board at 5 s,
+  // the highlighter marks from 6.5 s.
+  D2: capture('D2', 'liveview-powerbi.mp4', 9.566, 'View, LiveView, the Power BI window, Freeze, and highlighter marks.'),
+  // The measure is on the board on one line at 3 s; F6 at 5.3 s; formatted by 6.5 s.
+  D3: capture('D3', 'dax-f6.mp4', 9.233, 'A long one-line measure is pasted; F6 formats it.'),
+  // Insert at 0.8 s, a rectangle at 1.6 s, a diamond at 4.4 s, the connector at 6 s, the
+  // rectangle moved from 6.6 to 7.6 s with the arrow following.
+  D4: capture('D4', 'shapes-connectors.mp4', 10.1, 'Insert: shapes and a connector; a shape moves and the arrow follows.'),
+  // The board's content, the Export dialog at 3 s, Save at 7.3 s, PowerPoint from 8.4 s.
+  D5: capture('D5', 'frames-export.mp4', 11.033, 'Frames on the board, Export, and the deck open in PowerPoint.'),
+  // The .pptx is dropped at 0.8 s, the import dialog runs to 3.8 s, the slides are on the
+  // board at 4.4 s, and the view zooms out over them from 5 to 6.6 s.
+  D6: capture('D6', 'open-pptx-zip.mp4', 8.466, 'A .pptx dropped on the board becomes its slides.'),
+  // Zoomed in on ink; a double-click at 3.6 s fits the whole board by 4 s.
+  D7: capture('D7', 'full-board.mp4', 6.366, 'A double-click on empty canvas fits the whole board in the window.'),
+};
diff --git a/tools/films/src/film2/compositions.ts b/tools/films/src/film2/compositions.ts
new file mode 100644
index 0000000..0f6a5a0
--- /dev/null
+++ b/tools/films/src/film2/compositions.ts
@@ -0,0 +1,12 @@
+import type {CutId} from './cuts';
+
+// Film 2's compositions: the film in three shapes, and the three portrait shorts. The
+// render and stills scripts read this list too.
+export const film2Compositions: {id: string; shapeId: string; cutId: CutId}[] = [
+  {id: 'film2-16x9', shapeId: '16x9', cutId: 'film'},
+  {id: 'film2-1x1', shapeId: '1x1', cutId: 'film'},
+  {id: 'film2-4x5', shapeId: '4x5', cutId: 'film'},
+  {id: 'film2-short-liveview', shapeId: '9x16', cutId: 'liveview'},
+  {id: 'film2-short-dax', shapeId: '9x16', cutId: 'dax'},
+  {id: 'film2-short-shapes', shapeId: '9x16', cutId: 'shapes'},
+];
diff --git a/tools/films/src/film2/cuts.ts b/tools/films/src/film2/cuts.ts
new file mode 100644
index 0000000..9c51ea9
--- /dev/null
+++ b/tools/films/src/film2/cuts.ts
@@ -0,0 +1,109 @@
+// The cuts of film 2: the 50-second film and the three 12-second shorts. Each is a list
+// of camera moves over the board and, for each capture, when it plays.
+//
+// Every move uses the one easing curve in brand.ts. The camera rests on a station with a
+// slow push-in, leaves it, and dips back a little in the middle of each move so the
+// board around the stations shows as it passes.
+
+import type {StationId} from './captures';
+
+export type CutId = 'film' | 'liveview' | 'dax' | 'shapes';
+
+export type Segment =
+  // Rest on a station, pushing in. `zoomFrom` starts the push-in further back, as a
+  // fraction of the station's zoom.
+  | {kind: 'hold'; t0: number; t1: number; at: StationId; zoomFrom?: number}
+  // Move from one station to the next. `dip` is how far the zoom drops mid-move.
+  | {kind: 'move'; t0: number; t1: number; from: StationId; to: StationId; dip: number}
+  // Pull back from a station until the whole board is in frame.
+  | {kind: 'pull'; t0: number; t1: number; from: StationId}
+  // Rest on the whole board.
+  | {kind: 'whole'; t0: number; t1: number};
+
+// When a capture starts playing (seconds of the cut), where in the capture it starts,
+// and how fast it plays. Before `start` the window holds the frame at `from`; after the
+// capture ends it holds the last frame.
+export type Play = {start: number; from: number; rate: number};
+
+export type Cut = {
+  id: CutId;
+  seconds: number;
+  camera: Segment[];
+  plays: Partial<Record<StationId, Play>>;
+  // When the board gives way to the end card.
+  endCard: number;
+  // The on-screen copy of the closing line, shown on the board below the stations.
+  closing: boolean;
+};
+
+// The on-screen text of each station. It is final copy.
+export const captions: Record<StationId, string> = {
+  D1: 'SQLBI Whiteboard',
+  D2: 'Capture a running application onto the board and draw on it.',
+  D3: 'Paste DAX or SQL. F6 formats it.',
+  D4: 'Shapes, sticky notes, and arrows that follow.',
+  D5: 'Frames become slides. Export the deck.',
+  D6: 'Open a PowerPoint deck or a Microsoft Whiteboard export.',
+  D7: '',
+};
+
+export const CLOSING = 'One board. A file on your PC.';
+
+// The film: 0–6 s D1, 6–13 D2, 13–20 D3, 20–27 D4, 27–34 D5, 34–41 D6, 41–47 the pull
+// back to the whole board, 47–50 the end card. Each move is centred on the beat change.
+const film: Cut = {
+  id: 'film',
+  seconds: 50,
+  camera: [
+    {kind: 'hold', t0: 0, t1: 5, at: 'D1'},
+    {kind: 'move', t0: 5, t1: 7, from: 'D1', to: 'D2', dip: 0.2},
+    {kind: 'hold', t0: 7, t1: 12, at: 'D2'},
+    {kind: 'move', t0: 12, t1: 14, from: 'D2', to: 'D3', dip: 0.2},
+    {kind: 'hold', t0: 14, t1: 18.7, at: 'D3'},
+    {kind: 'move', t0: 18.7, t1: 21.3, from: 'D3', to: 'D4', dip: 0.32},
+    {kind: 'hold', t0: 21.3, t1: 26, at: 'D4'},
+    {kind: 'move', t0: 26, t1: 28, from: 'D4', to: 'D5', dip: 0.2},
+    {kind: 'hold', t0: 28, t1: 33, at: 'D5'},
+    {kind: 'move', t0: 33, t1: 35, from: 'D5', to: 'D6', dip: 0.2},
+    {kind: 'hold', t0: 35, t1: 41, at: 'D6'},
+    {kind: 'pull', t0: 41, t1: 45.2, from: 'D6'},
+    {kind: 'whole', t0: 45.2, t1: 47.4},
+  ],
+  plays: {
+    // The diagram is drawn by 7.2 s of the capture, at 5.1 s of the film.
+    D1: {start: 0, from: 0.2, rate: 1.4},
+    // The Power BI window lands at 9.4 s and the marks go on from 10.4 s.
+    D2: {start: 6, from: 0.3, rate: 1.4},
+    // The paste reads at 15 s and F6 at 16.7 s.
+    D3: {start: 13, from: 0.4, rate: 1.3},
+    // The shapes go in from 21.3 s; the arrow follows the moved shape at 25 s.
+    D4: {start: 20, from: 0.3, rate: 1.3},
+    // The Export dialog at 28.9 s, PowerPoint from 32.3 s.
+    D5: {start: 27, from: 0.2, rate: 1.6},
+    // The import dialog from 35.1 s, the slides on the board at 38 s.
+    D6: {start: 34.2, from: 0, rate: 1.15},
+    // The double-click fits the board at 44.6 s, while the camera pulls back.
+    D7: {start: 41.6, from: 1.0, rate: 1},
+  },
+  endCard: 47,
+  closing: true,
+};
+
+// A short is one station of the film in portrait: the camera pushes in on it from a
+// little further back for the whole clip, the capture plays at its own speed, and the
+// clip ends on a 2-second end card.
+const short = (id: CutId, at: StationId, play: Play): Cut => ({
+  id,
+  seconds: 12,
+  camera: [{kind: 'hold', t0: 0, t1: 10.4, at, zoomFrom: 0.9}],
+  plays: {[at]: play},
+  endCard: 10,
+  closing: false,
+});
+
+export const cuts: Record<CutId, Cut> = {
+  film,
+  liveview: short('liveview', 'D2', {start: 0.3, from: 0.3, rate: 1}),
+  dax: short('dax', 'D3', {start: 0.6, from: 0.4, rate: 1}),
+  shapes: short('shapes', 'D4', {start: 0.2, from: 0.3, rate: 1}),
+};