@erclx/canon 5.69.0 → 5.71.0

package/src/design/render.ts

@@ -3,6 +3,7 @@ import { join } from 'node:path'
 import type { Cell, DesignDoc, Row } from '@/design/parse'
 import { parseDesignDoc } from '@/design/parse'
 import { fontFaceBlock } from '@/design/css'
+import { faviconLink } from '@/design/favicon'
 import type { FontFace } from '@/design/fonts'
 import { FONT_FACES } from '@/design/fonts'
 import { colorValue } from '@/design/tokens'
@@ -12,16 +13,6 @@ export interface RenderResult {
   cssPath: string
 }
 
-/**
- * The same path data as `assets/brand/mark.svg`, colored via `colorValue`
- * since a data URI has no CSS context to resolve `currentColor` against and
- * this page renders on the light chrome `previewChrome()` sets up.
- */
-const FAVICON_COLOR = colorValue('light-accent') ?? '#a4471c'
-const FAVICON_HREF = `data:image/svg+xml,${encodeURIComponent(
-  `<svg xmlns="http://www.w3.org/2000/svg" viewBox="10 10 80 80"><path d="M34,20 L15,28 L15,72 L34,80 Z M66,20 L85,28 L85,72 L66,80 Z" fill="${FAVICON_COLOR}" /><rect x="44" y="15" width="12" height="70" rx="2" fill="${FAVICON_COLOR}" /></svg>`,
-)}`
-
 export interface RenderOptions {
   /**
    * Declare each vendored face the typography table names, and let the page
@@ -29,6 +20,11 @@ export interface RenderOptions {
    * base64 block a target's render would otherwise grow by unasked.
    */
   readonly embedFonts?: boolean
+  /**
+   * A rendered favicon SVG to inline in the head. The caller reads and renders
+   * the mark, so this module reads no brand file a target does not carry.
+   */
+  readonly favicon?: string
 }
 
 export function renderDesignDoc(
@@ -42,7 +38,10 @@ export function renderDesignDoc(
   const htmlPath = join(outDir, 'index.html')
   const faces = options.embedFonts ? namedFaces(doc) : []
   writeFileSync(cssPath, buildCss(doc, faces))
-  writeFileSync(htmlPath, buildHtml(doc, bodyFamily(doc, faces)))
+  writeFileSync(
+    htmlPath,
+    buildHtml(doc, bodyFamily(doc, faces), options.favicon),
+  )
   return { htmlPath, cssPath }
 }
 
@@ -218,7 +217,11 @@ function previewChrome(): string {
   return ['  :root {', ...lines, '  }'].join('\n')
 }
 
-function buildHtml(doc: DesignDoc, bodyStack: string): string {
+function buildHtml(
+  doc: DesignDoc,
+  bodyStack: string,
+  favicon: string | undefined,
+): string {
   const sections = [
     sectionPersonality(doc.personality),
     sectionColor(doc.color),
@@ -239,8 +242,7 @@ function buildHtml(doc: DesignDoc, bodyStack: string): string {
   return `<!doctype html>
 <html lang="en">
 <head>
-<meta charset="utf-8">
-<link rel="icon" href="${FAVICON_HREF}">
+<meta charset="utf-8">${favicon === undefined ? '' : `\n${faviconLink(favicon)}`}
 <title>Design tokens</title>
 <link rel="stylesheet" href="design.css">
 <style>

package/src/design/tokens.ts

@@ -100,7 +100,7 @@ export const REVIEWED = '2026-10-24'
 
 export const TOKENS: DesignTokens = {
   personality:
-    'Warm neutrals under one rust accent, set in Geist. The page reads as prose, and monospace appears only where a surface shows what a shell printed. One accent carries every count, link, and primary action.',
+    'Warm neutrals with actions in ink, set in Geist. The page reads as prose, and monospace appears only where a surface shows a path, a command, or what a shell printed. The rust accent marks a status the surface it shows would color, and the landing page carries none, leaving the vermilion pip of the mark as its one hue.',
 
   colorRules: [
     'One accent. Never promote a second color into a structural role.',
@@ -155,7 +155,7 @@ export const TOKENS: DesignTokens = {
     },
     {
       role: 'accent',
-      intent: 'install command, mark, primary action',
+      intent: 'a status the surface would color, such as an open pull request',
       value: '#c76b5f',
       grounds: DARK_GROUNDS,
     },
@@ -208,7 +208,7 @@ export const TOKENS: DesignTokens = {
     },
     {
       role: 'light-accent',
-      intent: 'links and primary action on light',
+      intent: 'a status the surface would color, on light',
       value: '#ad4a4b',
       grounds: LIGHT_GROUNDS,
     },
@@ -361,6 +361,7 @@ export const TOKENS: DesignTokens = {
 
   iconography: [
     'No icon library. `assets/brand/mark.svg` is the one authored icon.',
+    'The mark takes its own colors from `src/design/favicon.ts`, never the accent: the c in the text ink and the pip in a vermilion pair.',
     'The terminal draws glyphs: `│ ├ ✓ ! ✗ + - ◆ ◇ ❯`.',
   ],
 }

package/src/gate/stages.ts

@@ -248,6 +248,12 @@ export const STAGES: readonly Stage[] = [
         failure:
           'The tab icon drifted from the token source. Run bun run check and commit web/public/favicon.svg.',
       },
+      {
+        kind: 'drift',
+        pathspec: 'assets/brand/mark-color*.svg',
+        failure:
+          'The README mark pair drifted from the mark source. Run bun run check and commit assets/brand/mark-color.svg and assets/brand/mark-color-light.svg.',
+      },
       { kind: 'measure', measure: designProse },
     ],
     success: 'Design source clean',

package/src/init/steps.ts

@@ -7,8 +7,8 @@ import { GATED_CONFIG_REL, gateScopeRoots } from '@/markdown/gated'
 export type RunFactory = (args: readonly string[]) => () => Promise<boolean>
 
 /**
- * States the same fact as `docs/target/migrations.md`'s backup section in its
- * own words. Keep the two in step by hand; nothing compares them.
+ * States the same fact as `docs/migrations/by-hand.md`'s backup section
+ * in its own words. Keep the two in step by hand; nothing compares them.
  */
 const RECORDS_SETUP_NOTICE =
   "No private repository to push to yet. Run 'canon records push' once one exists to print the one-time setup command, or --skip records to silence this."

package/src/markdown/colons.ts

@@ -22,8 +22,14 @@ const QUOTE_MARKER = /^(?:\s*>\s?)+/
 /** A colon followed by whitespace and more text, ruling out `10:30` and a scheme. */
 const COLON = /:(?=\s+\S)/g
 
+/** A colon followed by whitespace, which a masked code span leaves behind. */
+const LABEL_COLON = /:\s/
+
 const BOLD_LABEL = /^(\*\*|__)[^*_]+\1$/
 
+/** What may stand in a lead once its code spans and links are masked. */
+const CONNECTIVE = /\b(?:and|or|to)\b|,/g
+
 /** Blanks a span while holding its width, so a column stays where it was. */
 function blank(match: string): string {
   return ' '.repeat(match.length)
@@ -32,14 +38,74 @@ function blank(match: string): string {
 /**
  * Whether the text before a line's first colon is a label rather than a
  * clause: the lead of a list item, or a prefix that is only emphasis and a
- * masked code span.
+ * masked code span. A list item's lead also reads as a label at any length
+ * when only code spans, links, commas, and `and`, `or`, or `to` stand in it,
+ * which is a file entry naming several paths.
  */
 function isLabel(prefix: string, listItem: boolean): boolean {
   if (BOLD_LABEL.test(prefix.trim())) return true
 
   const words = prefix.replace(/[*_]/g, ' ').trim()
   if (words === '') return true
-  return listItem && words.split(/\s+/).length <= 4
+  if (!listItem) return false
+  if (words.replace(CONNECTIVE, ' ').trim() === '') return true
+  return words.split(/\s+/).length <= 4
+}
+
+interface Entry {
+  readonly line: BodyLine
+  readonly masked: string
+  readonly start: number
+  /** Width of the quote marker and the item's own leading whitespace. */
+  readonly indent: number
+  readonly quote: string
+  readonly isItem: boolean
+  /** Matches at or past the content start, the only ones a line can report. */
+  readonly colons: readonly RegExpExecArray[]
+  /** A colon stands past the content start, even with only a masked span after it. */
+  readonly labelColon: boolean
+  /** Items sharing one list at one indent, shared by reference. */
+  group?: Entry[]
+}
+
+/**
+ * Collects consecutive items at one indent into a list. A blank line, a
+ * heading, or a change of quote depth ends every open list, and a deeper child
+ * neither joins its parent's list nor ends it.
+ */
+function groupItems(entries: readonly Entry[]): void {
+  const open = new Map<number, Entry[]>()
+  let quote = ''
+
+  for (const entry of entries) {
+    if (entry.line.fenced) continue
+
+    const empty = entry.masked.slice(entry.quote.length).trim() === ''
+    if (entry.quote !== quote || empty || HEADING.test(entry.line.text)) {
+      open.clear()
+    }
+    quote = entry.quote
+    if (!entry.isItem) continue
+
+    for (const level of open.keys()) {
+      if (level > entry.indent) open.delete(level)
+    }
+
+    const group = open.get(entry.indent) ?? []
+    open.set(entry.indent, group)
+    group.push(entry)
+    entry.group = group
+  }
+}
+
+/** Whether the item sits in a list of two or more where every item has a colon. */
+function uniform(entry: Entry): boolean {
+  const group = entry.group
+  return (
+    group !== undefined &&
+    group.length >= 2 &&
+    group.every((item) => item.labelColon)
+  )
 }
 
 /**
@@ -47,30 +113,50 @@ function isLabel(prefix: string, listItem: boolean): boolean {
  *
  * A heading, a table row, a fence, a code span, a link, and a line-final colon
  * are left alone, and so is the first colon of a list item or of a line opening
- * on a bold or code label. The measure is advisory, because a colon is
- * sometimes right and the corpus count shows a gate would be a sweep nobody
- * asked for.
+ * on a bold or code label, and of every item in a list where each one carries a
+ * colon. The measure is advisory, because a colon is sometimes right and the
+ * corpus count shows a gate would be a sweep nobody asked for.
  */
 export function findColons(lines: readonly BodyLine[]): ColonFinding[] {
-  const found: ColonFinding[] = []
-
-  for (const line of lines) {
-    if (line.fenced || HEADING.test(line.text) || TABLE_ROW.test(line.text)) {
-      continue
-    }
-
+  const entries: Entry[] = lines.map((line) => {
     const masked = maskDisplayed(line.text.replace(LINK, blank))
     const quote = QUOTE_MARKER.exec(masked)?.[0] ?? ''
     const marker = LIST_MARKER.exec(masked.slice(quote.length))?.[0] ?? ''
     const start = quote.length + marker.length
-    let labelled = false
+    const skipped =
+      line.fenced || HEADING.test(line.text) || TABLE_ROW.test(line.text)
+
+    return {
+      line,
+      masked,
+      start,
+      indent: quote.length + marker.length - marker.trimStart().length,
+      quote: quote.replace(/\s/g, ''),
+      isItem: !skipped && marker !== '',
+      labelColon: !skipped && LABEL_COLON.test(masked.slice(start)),
+      colons: skipped
+        ? []
+        : [...masked.matchAll(COLON)].filter((match) => match.index >= start),
+    }
+  })
+
+  groupItems(entries)
 
-    for (const match of masked.matchAll(COLON)) {
-      if (match.index < start) continue
+  const found: ColonFinding[] = []
+
+  for (const entry of entries) {
+    const { line, masked, start } = entry
+    let labelled = false
 
+    for (const match of entry.colons) {
       if (!labelled) {
         labelled = true
-        if (isLabel(masked.slice(start, match.index), marker !== '')) continue
+        if (
+          isLabel(masked.slice(start, match.index), entry.isItem) ||
+          (entry.isItem && uniform(entry))
+        ) {
+          continue
+        }
       }
 
       found.push({

package/src/migrate/status.ts

@@ -8,9 +8,9 @@ interface Migration {
 
 /**
  * Every `canon migrate` subcommand in the order a project runs them, records
- * first. This is the source for that order, and `docs/target/migrations.md`
- * cites the verb rather than keeping a second list. A new migration joins by
- * one line here.
+ * first. This is the source for that order, and
+ * `docs/migrations/by-verb.md` cites the verb rather than keeping a
+ * second list. A new migration joins by one line here.
  */
 export const MIGRATIONS: readonly Migration[] = [
   { name: 'records', flags: [] },

package/src/records/validate.ts

@@ -807,6 +807,13 @@ const STRUCTURE_FILES: Readonly<
   intake: (file) => file !== INTAKE_INDEX && file !== INTAKE_HANDOFF,
 }
 
+/**
+ * An app drive's log, which sits under an intake folder's `evidence/` and
+ * holds findings as headings and fields rather than items, so it reads on the
+ * plain criteria rather than the cluster exemptions.
+ */
+const DRIVE_LOG = 'evidence/drive-log.md'
+
 async function folderStructure(
   dir: string,
   kind: RecordKind,
@@ -817,9 +824,14 @@ async function folderStructure(
 
   const report = kind === 'intake' ? intakeStructure : structureFindings
   const files = (await listMarkdown(dir)).filter(reads)
+  const reports = files.map((file) => ({ file, read: report }))
+  if (kind === 'intake' && existsSync(join(dir, DRIVE_LOG))) {
+    reports.push({ file: DRIVE_LOG, read: structureFindings })
+  }
+
   const perFile = await Promise.all(
-    files.map(async (file) =>
-      report(await readFile(join(dir, file), 'utf8')).map((entry) => ({
+    reports.map(async ({ file, read }) =>
+      read(await readFile(join(dir, file), 'utf8')).map((entry) => ({
         ...entry,
         record: slug,
         subject: file,

package/src/sandbox/expect.ts

@@ -44,7 +44,15 @@ export interface AssertionResult {
  */
 export interface RunEnvelope {
   readonly isError: boolean
+  /** The runner cap ended the run, read from `subtype` rather than `turns`. */
+  readonly isTruncated: boolean
   readonly turns: number
+  /**
+   * The cap the run ran under. `num_turns` counts more than the cap does, so
+   * an untruncated run can report past it, and a ceiling at or above the cap
+   * is held by `isTruncated` instead. A non-finite value reads as absent.
+   */
+  readonly turnCap?: number
   readonly denials: number
   readonly reply?: string
 }
@@ -487,6 +495,23 @@ function checkReply(
   }
 }
 
+function isFiniteCap(turnCap: number | undefined): turnCap is number {
+  return turnCap !== undefined && Number.isFinite(turnCap)
+}
+
+function capped(turnCap: number | undefined): string {
+  return isFiniteCap(turnCap) ? ` of ${turnCap} turns` : ''
+}
+
+/**
+ * A ceiling below the cap was declared in `num_turns` and is compared in it. One
+ * at or above the cap skips with no result, since emitting a pass would let the
+ * envelope pass a run.
+ */
+function isBelowCap(maxTurns: number, turnCap: number | undefined): boolean {
+  return !isFiniteCap(turnCap) || maxTurns < turnCap
+}
+
 /**
  * The envelope never determines a pass. It can only fail a run the expectations
  * would otherwise have passed. Under `bypassPermissions` the denial count is
@@ -516,8 +541,15 @@ function checkEnvelope(
       message: `envelope: ${envelope.denials} permission denials`,
     })
   }
+  if (envelope.isTruncated) {
+    results.push({
+      ok: false,
+      message: `envelope: truncated by the runner cap${capped(envelope.turnCap)}`,
+    })
+  }
   if (
     expectation.maxTurns !== undefined &&
+    isBelowCap(expectation.maxTurns, envelope.turnCap) &&
     envelope.turns > expectation.maxTurns
   ) {
     results.push({

package/src/sandbox/headless/run.ts

@@ -45,9 +45,12 @@ import {
  *
  * `maxTurns` is the only budget. `max_turns` in an arm's `expect.toml` is a
  * ceiling asserted after the run, not a cap enforced during it, so a
- * declaration cannot raise what it runs under. An arm needing more than this
- * truncates, and a truncated run fails the same assertions a reasoning miss
- * does with nothing to separate them.
+ * declaration cannot raise what it runs under. A truncated run exits 1 with
+ * `subtype` `error_max_turns`, which `canon sandbox check` fails by name.
+ * `num_turns` counts more than this cap does, so a ceiling at or above it is
+ * held by the cap and compares nothing. The check reads the cap from its own
+ * environment, so a run under a raised cap, checked later by hand without the
+ * variable, reads the default.
  *
  * `bypassPermissions` is the only mode that lets a run write under `.claude/`,
  * which most arms need. The scoping the permission layer would have given

package/src/take/camera.ts

@@ -1,5 +1,6 @@
 import {
   type Box,
+  CLIP_SIZES,
   type LogEvent,
   type Point,
   type TakeLog,
@@ -21,7 +22,7 @@ import {
 /**
  * Turns a take's log into one camera per frame, preset O4 from groundwork
  * track `193-ui-record`, a folder name kept as written (canon-keep-retired).
- * The preset is OpenScreen's timing aimed at each click, a fixed depth, a focus that holds still until a click leaves the inner part of the
+ * The preset is OpenScreen's timing aimed at each click, a fixed depth the clip's resolution caps, a focus that holds still until a click leaves the inner part of the
  * view, and a dead zone that keeps the cursor in frame. HyperFrames renders the
  * track as it stands, so it carries no curve a renderer would have to agree on.
  */
@@ -31,6 +32,13 @@ export const CAMERA_VERSION = 1
 /** The depth every click zooms to, unless its target already fills the view. */
 const DEPTH = 1.8
 
+/**
+ * How far a clip with one pixel per CSS pixel zooms before it goes soft, which
+ * caps a screencast's depth well under `DEPTH` and leaves the stepper's 4K
+ * clip at it.
+ */
+const SHARP_DEPTH = 1.35
+
 /** How much of the zoomed view a target may fill, which caps the depth for a big one. */
 const FILL = 0.8
 
@@ -57,6 +65,13 @@ const EDGE = 0.9
 /** How long the click ring the edit draws takes to expand. */
 const RING_MS = 450
 
+/**
+ * How far a drag's ring grows before it holds for the drag, then runs on to 1
+ * from the release. A held value keeps the ring's one field, so every reader
+ * drawing a growing ring draws a held press with no change.
+ */
+const GRAB_RING = 0.3
+
 export interface CameraFrame {
   readonly ms: number
   /** How far the view is zoomed, 1 being the whole page. */
@@ -91,16 +106,30 @@ interface Window {
   readonly aims: Aim[]
 }
 
-export function cameraTrack(log: TakeLog): CameraTrack {
+export interface CameraOptions {
+  /**
+   * How much faster the edit plays the clip, so the track is built on the
+   * playback clock and a zoom settles at the speed a viewer sees. 1 by default.
+   */
+  readonly rate?: number
+}
+
+export function cameraTrack(
+  source: TakeLog,
+  options: CameraOptions = {},
+): CameraTrack {
+  const log = atRate(source, options.rate ?? 1)
   const { width, height } = log.viewport
+  const clip = log.clip ?? CLIP_SIZES[log.route]
+  const deepest = Math.min(DEPTH, (SHARP_DEPTH * clip.width) / width)
   const depthFor = (box: Box): number =>
     Math.min(
-      DEPTH,
+      deepest,
       (width * FILL) / Math.max(box.width, 1),
       (height * FILL) / Math.max(box.height, 1),
     )
 
-  const aims: Aim[] = log.events
+  const aims: Aim[] = (log.push === false ? [] : log.events)
     .flatMap((event): Aim[] => {
       if (event.kind === 'click') {
         return [
@@ -112,6 +141,19 @@ export function cameraTrack(log: TakeLog): CameraTrack {
           },
         ]
       }
+      if (event.kind === 'drag') {
+        // One aim over both ends, held to the release, so a short drag stays
+        // framed whole and a long one asks for a depth under MIN_ZOOM.
+        const box = union(event.box, event.drop)
+        return [
+          {
+            t: event.t,
+            until: event.t + event.ms,
+            at: { x: box.x + box.width / 2, y: box.y + box.height / 2 },
+            depth: depthFor(box),
+          },
+        ]
+      }
       if (event.kind === 'type') {
         const box = event.box
         return [
@@ -129,9 +171,26 @@ export function cameraTrack(log: TakeLog): CameraTrack {
     .sort((a, b) => a.t - b.t)
 
   const scrolls = log.events.filter((event) => event.kind === 'scroll')
-  // Read off every click rather than off the aims, which drop a click too large
+  // Read off every press rather than off the aims, which drop a click too large
   // to zoom and add a typing burst that is no press.
-  const clicks = log.events.filter((event) => event.kind === 'click')
+  const presses = log.events.flatMap((event) =>
+    event.kind === 'click'
+      ? [{ t: event.t, release: event.t }]
+      : event.kind === 'drag'
+        ? [{ t: event.t, release: event.t + event.ms }]
+        : [],
+  )
+  const ringAt = (ms: number): number | null => {
+    for (const press of presses) {
+      if (ms < press.t) continue
+      const grown = (ms - press.t) / RING_MS
+      if (ms <= press.release) return Math.min(GRAB_RING, grown)
+      const held = Math.min(GRAB_RING, (press.release - press.t) / RING_MS)
+      const ring = held + (ms - press.release) / RING_MS
+      if (ring <= 1) return ring
+    }
+    return null
+  }
   const windows = zoomWindows(aims, scrolls)
 
   const targetAt = (ms: number) => {
@@ -196,16 +255,14 @@ export function cameraTrack(log: TakeLog): CameraTrack {
       cursor.y + half.y * EDGE,
     )
 
-    const ring = clicks.find(
-      (click) => ms >= click.t && ms - click.t <= RING_MS,
-    )
+    const ring = ringAt(ms)
     frames.push({
       ms: round(ms, 2),
       scale: round(scale, 4),
       x: round(clamp(springs.x.value, half.x, width - half.x) - half.x, 2),
       y: round(clamp(springs.y.value, half.y, height - half.y) - half.y, 2),
       cursor: roundPoint(cursor),
-      ring: ring ? round((ms - ring.t) / RING_MS, 3) : null,
+      ring: ring === null ? null : round(ring, 3),
     })
   }
 
@@ -217,6 +274,27 @@ export function cameraTrack(log: TakeLog): CameraTrack {
   }
 }
 
+/** Reads a playback rate off a flag, which has to be a positive number. */
+export function readRate(value: string): number | undefined {
+  const rate = Number(value)
+  return Number.isFinite(rate) && rate > 0 ? rate : undefined
+}
+
+/** The log as a clip played `rate` times faster shows it, every time divided. */
+function atRate(log: TakeLog, rate: number): TakeLog {
+  if (rate === 1) return log
+  return {
+    ...log,
+    frames: Math.round(log.frames / rate),
+    events: log.events.map((event): LogEvent => {
+      const t = event.t / rate
+      return 'ms' in event
+        ? { ...event, t, ms: event.ms / rate }
+        : { ...event, t }
+    }),
+  }
+}
+
 /**
  * Groups aims into zooms. One holds from its first aim to the last plus the
  * hold, a scroll ends it since the content moves under the camera, and the next
@@ -295,6 +373,17 @@ function focusAt(
   return focus
 }
 
+function union(a: Box, b: Box): Box {
+  const x = Math.min(a.x, b.x)
+  const y = Math.min(a.y, b.y)
+  return {
+    x,
+    y,
+    width: Math.max(a.x + a.width, b.x + b.width) - x,
+    height: Math.max(a.y + a.height, b.y + b.height) - y,
+  }
+}
+
 function clamp(value: number, low: number, high: number): number {
   return Math.min(Math.max(value, low), high)
 }

package/src/take/film.ts

@@ -4,6 +4,7 @@ import { isBrowserMissing, isServerUnreachable } from '@/browser/engine'
 import { cameraTrack } from '@/take/camera'
 import { FfmpegMissing, requireFfmpeg } from '@/take/encode'
 import {
+  CLIP_SIZES,
   FPS,
   LOG_VERSION,
   type LogEvent,
@@ -60,6 +61,10 @@ export type TakeResult =
       readonly reason: TakeRefusal
       readonly message: string
       readonly beat?: string
+      /** Why the refused beat had fallen back to a screencast, when it had. */
+      readonly fallback?: string
+      /** The page as the failing step met it, relative to the take's folder. */
+      readonly still?: string
     }
 
 export interface TakeRequest {
@@ -121,7 +126,15 @@ export async function take(request: TakeRequest): Promise<TakeResult> {
         ),
       )
     } catch (error) {
-      return failed(classify(error), error, beat.name)
+      const cause = error instanceof FellBack ? error.error : error
+      const shot = cause instanceof TargetMissing ? cause.still : undefined
+      const still = shot ? join(dir, 'still.jpg') : undefined
+      if (shot && still) writeFileSync(join(out, still), shot)
+      return {
+        ...failed(classify(cause), cause, beat.name),
+        ...(error instanceof FellBack ? { fallback: error.fallback } : {}),
+        ...(still ? { still } : {}),
+      }
     }
   }
 
@@ -159,7 +172,11 @@ async function filmBeat(
       if (!(error instanceof StepperStalled)) throw error
       route = 'screencast'
       fallback = error.message
-      filmed = await filmScreencast({ url, beat, clip: target })
+      try {
+        filmed = await filmScreencast({ url, beat, clip: target })
+      } catch (cause) {
+        throw new FellBack(cause, fallback)
+      }
     }
   } else {
     filmed = await filmScreencast({ url, beat, clip: target })
@@ -170,6 +187,8 @@ async function filmBeat(
     viewport: VIEWPORT,
     fps: FPS,
     route,
+    clip: CLIP_SIZES[route],
+    ...(beat.push === false ? { push: false as const } : {}),
     frames: filmed.frames,
     events: filmed.events,
   }
@@ -196,6 +215,20 @@ async function filmBeat(
   }
 }
 
+/**
+ * A beat that failed in the screencast it fell back to, carrying why it fell
+ * back, since the fallback loads the page a second time and a single-use link
+ * is spent by then.
+ */
+class FellBack extends Error {
+  constructor(
+    readonly error: unknown,
+    readonly fallback: string,
+  ) {
+    super(error instanceof Error ? error.message : String(error))
+  }
+}
+
 function classify(error: unknown): TakeRefusal {
   if (error instanceof TargetMissing) return 'target-missing'
   if (error instanceof ShellMissing || isBrowserMissing(error)) {