summaryrefslogtreecommitdiff
path: root/anim/README.md
blob: c59630a5dec9e0ab0fb02b37bb53a1d6060cea3f (plain) (blame)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
# canim

Animations of how a program ran, from a `ztrace` recording, on sketchbook's
`anim` (live scenes). The frame is a debugger's whole context, as pwndbg
shows it, with one lens over it; the names, sizes and colours of everything
in it are the design language's catalogue (`../design/README.md`), and how
it moves is `../design/motion.md`. Code and design share one set of names:
a block of the catalogue is a function or a component of the same name here.

```sh
zig build record                         # the recordings, into zig-out/recordings
zig build run -Dscene=fib                # a scene in a window, hot reload (zig build lib --watch)
zig build export -Dscene=fib -- DIR --fps 60 --size 1920x1080    # frames as PNGs (or - for raw RGBA)
zig build videos -Doptimize=ReleaseFast  # every scene: out/NAME-1080.mp4 and out/NAME-2160.mp4 (x264, 60 fps)
zig build test                           # unit tests, each scene run headless, and the gallery against its pictures
zig build gallery                        # the gallery's pictures drawn anew into test/gallery
zig build bench                          # what a recording costs a frame
zig build bench -- NAME BY [FUNCTION]    # a recording's steps (BY: moment, line, over), with what each changed
python3 tools/chart.py chart out/fib-1080.mp4 --out out/motion/fib   # the designer's timing chart and five checks
```

Needs what sketchbook and ztrace need, and `setarch`, `clang` (the pass
plugin), `ffmpeg` (videos), python with numpy and Pillow (charts). The
`sqlite` scene also needs SQLite's amalgamation (`-Dsqlite=DIR`, the
directory of `sqlite3.c` and `sqlite3.h`; by default
`~/05-genizah/sqlite/sqlite-amalgamation-3500400`) and `objdump`; where
the directory is not there the scene is not made, and the rest builds
and tests as before.
Dependencies are by path (`..` is ztrace, `../../sketchbook`,
`../../02-pardes-code`); `zig-pkg` is a symlink to pardes's.

## A scene

```zig
const anim = @import("anim");
const canim = @import("canim");
const recordings = @import("recordings");

pub const background = canim.background;
pub const scene = anim.Live(frame, struct {});

fn frame(s: *anim.Frame) void {
    const rec = canim.open(recordings.steps);              // a recording the build made and embedded
    var at = canim.cursor(s, rec, rec.lineMoment(10, rec.call("main", 0).enter));
    at.levels = .{ .idea = .calls, .source_rows = 10 };    // what a step is timed by
    at.journey(.line, rec.call("fib", 0).exit.?);          // the clock's whole way
    // The stage: the band (the lens) over the program column and the state column.
    const ctx = canim.context(s, at, .{ .split = canim.layout.split.subject });
    const tree = canim.callTree(s, .{ .cursor = at, .stage = ctx.stage, .function = "fib" });
    const joins = ctx.ties(s);                             // thread, link, projection; add it last
    var says: canim.Narrator = .{};

    canim.establish(s, .{ ctx.clock, ctx.registers, ctx.stack, ctx.source, ctx.disasm, tree, joins });
    says.line(s, "`fib` calls itself.");                   // old caption out, a gap, new one in, then stillness
    at.walk(s, .line, rec.lineMoment(6, rec.call("fib", 0).enter));   // each step in full, timed by its content
    at.hurry(s, .line, rec.call("fib", 4).enter, .{});     // a run: ramps in and out, counted on the clock
    ctx.stage.relayout(s, canim.layout.split.none);        // a change of split, 48 f
    s.wait(canim.theme.time.before_cut);
}
```

`frame` runs every frame and builds the whole timeline each time; a
component is an `anim` object (`fadeIn`, `fadeOut`) that draws the program's
state at the cursor, at the box its `Stage` gives it now.

**The cursor** (`src/cursor.zig`) moves in steps from one moment straight to
a later one (`Recording.Stop`: `.moment`, `.line`, `.over`, `.call`,
`.syscall`). For each step it writes a timetable, a `Plan`: the cascade.
The line fires (12 f); each level the step touched strikes 18 f after the one
before, in the order CPU, memory, idea (a level the scene does not show, or
the step did not touch, or touched nothing drawn, gives up its slot; a
drawing made of bytes strikes when the projection from them arrives, 24 f
after them, and its write 12 f later still; a call's node when the
projection from its return address does, 36 f after); the writes of one step strike 6 f apart; a hold to read; the
mark advances last; a rest. `walk` plays steps in full, `hurry` ramps the
pace down and up again (each step 0.6 of the one before) to a run (0.30 s a
step) or a sprint, `step` takes an explicit `Plan` (`Array.swap`,
`syscalls.step`), and `continue` goes to a stop far from this one (a
breakpoint): the line it leaves fires, the registers it changed strike in
a wave 2 f apart in pwndbg's order (fill 6 f, no arm, no pulse), then
memory and the idea, a 36 f hold, the mark out and in (6 f each, the
source fading through first if far), a 24 f rest. Components read it
through `Cursor.now(at)`.

## The scenes

| Scene | Shows | Split, lens | Recording |
| --- | --- | --- | --- |
| `title` | the series and the legend of marks | a card | |
| `fib` | recursion: each call a frame and a node | `subject`, `calls` | `steps` |
| `list` | a list reversed: each `next` turned; it opens on the map and dives into the frame; after the first load the pointer loaded opens in a loupe, and the `next` in it one deeper | `subject`, `nodes` | `list` |
| `sort` | insertion sort: compares and swaps | `subject`, `array` | `sort` |
| `syscalls` | open, read, close, write: the kernel's side | `subject`, `syscalls` | `hello` |
| `zoom` | one line of C as its instructions, the call's bytes | `none`, the camera at x2 | `steps` |
| `sqlite` | a row's way to disk in SQLite: from `sqlite3_step` to `sqlite3BtreeInsert` (three continues, the row's struct on the stack), the commit's `unixWrite` nine calls under `main`, `pwrite64` of page 2 into the kernel, and the page read as a B-tree leaf | `subject`, `backtrace` (`Context.Options.backtrace`), then `syscalls`; its view a `hexdump.Dump` | `sqlite` |
| `gallery` | every block in its states | all three | `gallery` |

## The blocks

The catalogue's layers, and where each block is. Every block is drawn in
every state the code has in the `gallery` scene.

| Layer | Block | Where | Notes |
| --- | --- | --- | --- |
| 0 tokens | grid, colour, type, the splits | `src/theme.zig` | per "Token changes" (`metric.calls`, `time.pin`, `time.continue_wave`, `time.relayout_fade` there; the insn's character counts gone); JetBrains Mono NL (`.code*` faces) for all mono, Medium under 30 |
| 1 atom | `address` (`lead`, `name`, `rwx`), `value` (and `Ui.typed`: `fd`, `bool`, `char`), `arrow` (`points`, `holds`, `more`), `mark`s, `plaque` (`chip`), `pin` (`row`, `under`), `bracket` (`quiet`, `tie`, `thread`), `tag` | `src/ui.zig` (`Ui.address`, `.value`, `.arrow`, `.written`, `.corner`, `.read`, `.cellWritten`, `.cellRead`, `.current`, `.trail`, `.unknown`, `.chip`, `.pinRow`, `.pinUnder`, `.bracket`, `.panel`) | marks as mock 15's column B: `current` the white wash (`color.wash`) and the gold plaque; `struck` the softened paper (`color.struck`) with bold bright digits; `held` a turned corner (9; 12 on a lens's cell), in over the cool's last 6 f (`Heat.corner`, `time.strike.corner`); `armed`, `read` |
| | `byte` | `src/rows.zig` `bytes` | `number`, `pointer`, `text` (a string's ink), `loose` (a byte of no field: the allocator's, padding, past what a dump is of), `unread`; `pad`; `bytesAt` moves the bytes right of a long (stack) address, by the dump's widest |
| 2 row | `chain`, `reg` (and `rip` with the flags), `slot`, `line`, `bytes`, `call` (`span`, `callRow`) | `src/rows.zig` | `chain` follows `zt.telescope.chase`; cut at its far end, `more`. `slot`: pins from 16, the offset from rsp ranged right to 172, the address at 184, the chain, its role ranged right where the room ends, from `zt.telescope.slots` (`saved rbx`, a local's name in primary, `argc`, `argv[0]`, `argv end`, `envp end`, `auxv`; nothing for a return address or `.none`). `bytes`: the bracket at 24, the address at 34, the bytes 12 after it and at 132 at least |
| | `arc` | `src/rows.zig` (`Arcs`), `src/hexdump.zig` (`pointerArcs`) | a pointer to a row of its own panel: lanes at 4, 10, 16 in a dump or a loupe, 4 and 10 on the stack; longest outermost, a chain in one lane; standing at 60% toward the page, full in the step that writes or reads it and always in a loupe; rewritten: the old dashed with the arm, fading from 6 f after the strike as the new draws (12 f), quieting with the cool; a stub to the rule for a target in the region past the window, only in its step; a saved rbp's only in its step; a dump withholds the arcs an open loupe carries |
| | `insn` | `src/disasm.zig` | columns at 2, 31, 40, 134, 180, 264, 564; operands whole, the annotation from 564 or a character after them; then a size word goes, then the operands give way, never inside `[]`; `current`, `ran` (every instruction of the last three steps), `ahead`, `outside`; the jump lane from the jump just before the pc's moment |
| 3 panel | `registers`, `stack`, `backtrace` | `src/context.zig` | the stack's window on `[rsp, rbp+16)` keeping the touched word in view, its tag the first and last word shown (`rsp+20 to rsp+48`), rsp and rbp's pins travelling 18 f after rsp's strike (`time.pin`, keeping their place among the names they leave and join), at rest only where the register points; a window that moves farther than its own height (six or eight slots) fades out and in round memory's strike, and what it brings, and what changed before it, is plain; a frame's name longer than the spans' room shortens the chains beside it; `call` spans and the backtrace (`#n`, name, arguments at 384, file and line) from `zt.telescope.frames`, the frames two stops share sliding to their new depth; the backtrace as a lens's drawing with `Context.Options.backtrace` |
| | `source` | `src/source.zig` | the whole file in a window, its middle third; numbers as wide as the program's largest line (SQLite's six digits), the text moved right by as much; a window going farther than its own height fades out and in |
| | `disasm` | `src/disasm.zig` | 17 rows (9 as subject), fewer above near a function's start; the line column as wide as the source's; two windows that overlap scroll, others fade out and in |
| | `hexdump` | `src/hexdump.zig` | a lens's view (`hexdump.panel`): `bytes` rows and their reading, veiled at a sprint; one reading for every dump (`hexdump.reading`), a list a character apart, a typed number as its type reads (`char` quoted, `bool` by name); the address room once a dump, by its widest; `Dump`, a view of a region by the fields a scene gives it (`Field`: where, how long, read as a number, big-endian or not, a pointer, text, or left to the eye), the rows that hold a field and a `more` row for each stretch left out, and where those rows outnumber the window, a window kept round the first row a mark or the step is on, the rest folded into `more` rows; marks the scene plays, and the step's only from the stop it came in at (`since`); the bytes a syscall was given as the kernel took them (`given`), and only what the debugger read at the stop (`seen`) |
| | `loupe` | `src/loupe.zig` (`canim.loupe`, `Loupe.open`, `.close`) | five rows round a pointer's target, lifted (`color.lift`, `lift_tag`, `shade` 12 and 16; 20 and 26 deeper), hanging from its pointer (its tag on the row's foot, 92 left of the digits, clamped to the stage), a 4-high bracket under the digits its stem, the target's fields framed bright; from a register, or from a pointer field of a loupe; `open` 36 f (read 6, stem and rise 18 with the shadow, the frame 6 f after), `close` 12 f |
| | lenses: `nodes`, `array`, `calls`, `syscalls`, `backtrace` | `src/nodes.zig`, `src/array.zig`, `src/calls.zig` (`Tree`), `src/syscalls.zig` (`Crossing`), `src/context.zig` (`Backtrace`, `lens`) | the drawing in `band` (over the program column), its view in `view` (over the state column): `nodes` and `array` a dump (`hexdump.panel`), `calls` the backtrace with arguments, `syscalls` the bytes the call is given or fills, `backtrace` (eleven rows as subject, five beside) a `Dump` the scene gives; an `under` pin's names in the order they came, the first left |
| 4 tie | `thread`, `link` (and its `pin`), `projection`, `echo` | `src/ties.zig` | panels publish places (`anchor`); `Ties`, added last, draws in the channels: a link climbs to a node by the gutter's left lane and goes down to a slot by the right, its name riding its head, a target past the stack's window a stub and a row count; a projection from the view's bytes, or from a frame's return address to its call's node |
| 5 frame | `map`, `minimap`, `dive`, `surface` | `src/map.zig` (`Map`, `split`, `minimap`), `Context.map` | the working frame's panels bound to a stage of 3840 by 2160 (`map.split`: the drawing and the source, the disassembly 69, the view 32, the registers and the backtrace, the stack 69 from 16 words above rsp); its rows published while `ui.mapping`; the working windows outlined (2 `dim`, 4 out); the minimap the same at a twentieth under the clock (text as 1-unit strokes at 45% toward the page, marks as blocks; `ui.strokes`), the count ranged right at 1648; `Map.show`, `.dive` (outlines bright 6 f, veil to 24, each panel from its window to its place 60 f, 6 f apart in reading order, opaque on the way, its rows on the window's rows, its tag and rules in at the end; the map falls to the minimap's rect over 72 f; 120 f and 30 f still), `.surface` (the dive back, 84 f, then 30 f still); per-panel transforms through `context.at` (`context.zoomed`) |
| | `stage` and `relayout` | `src/stage.zig` | splits `none`, `beside`, `subject` (`theme.layout.split`): the band is `band` (the drawing) and `view`; `relayout` fades the drawing round its move; `holdStack` holds the stack's window for the camera, with `free` slots |
| | `clock`, `caption`, `veil`, `card` | `src/words.zig`, `src/root.zig` (`Narrator`, `Camera`) | the clock still while a step plays, its piece fading in once the mark lands; a caption stays its reading time; the title card is `scenes/title.zig` |
| 6 verb | `fire`, `arm`, `strike`, `cool`, `read`, `extend`, `link`, `project`, `travel` (pins), `advance`, `cascade`, `continue` (`Cursor.continue`, `Plan.wave`), `run`, `sprint`, `establish` (`Context.establish`: a drawing's elements fade in rising, no lines), `scroll`, `relayout`, `visit`, `say` | `src/cursor.zig` (the timetable), the blocks (each draws its state at the instant) | tokens in `theme.time`; a level gives up its slot when nothing it touched is drawn (`Recording.drawn`) |

`Recording` (`src/Recording.zig`) is the index every block reads: lines,
calls, syscalls, allocations, which registers and bytes each moment changed
and read (a debugger's `touch` reads count), each moment's `touch` and
`branch`, and each instruction's line.

## The recordings

`build.zig` records four programs of `tools/` under `ztrace record` (the
debugger: registers, the stack, what they point at, the instructions round
the pc with their lines and callees' parameter counts, what each stack
word is (`zt.telescope.slots`), at every stop: `--stack 1024 --around 256
--disasm 69`, what the map needs, except where noted), each
by a bare name in a directory of its own with an empty environment, without
address randomisation, with the tools built `ReleaseFast` (a step through
the agent's or the runtime's code is a moment, and a slow tracer stretches
the clock's retry loops it steps through). The instrumented ones are built
`-no-pie -fno-stack-protector -Wl,-z,now`: short addresses, no resolver
and no canary stepped through that the source does not say.

| Name | Program | Stops | Moments, bytes | Also |
| --- | --- | --- | --- | --- |
| `steps` | `fib.c`, static musl, `-O0` | every instruction | 1999, 431 KB (336 KB before) | |
| `hello` | `hello.c`, static musl | every line | 233, 126 KB (101 KB) | reads `tools/note` |
| `sort` | `sort.c`, `ztrace cc --instr vars --only sort,a` | every instruction, `--from main` | 5154, 799 KB (617 KB) | `--ring`: the variables' names and types; each `__zt_var` call is stepped (4 of them); `--stack 256` (below) |
| `list` | `list.c`, `ztrace cc --instr vars --only push,reverse,head` | every instruction, `--from reverse` | 3369, 782 KB (528 KB) | `--alloc --preload` the agent: allocator headers are read; the pushes (the agent's and the runtime's first calls) run through; `--stack 256` (below) |
| `gallery` | the old `list` by line, kept in `test/gallery/list.ztrace` | | 134, 88 KB | the gallery's pictures depend on the drawing only |
| `sqlite` | `sqlite.c` (three rows into a table, committed) with SQLite 3.50.4's amalgamation, system clang `-O2 -g -fno-omit-frame-pointer -no-pie -fno-stack-protector -Wl,-z,now`, glibc | `--by break`: `sqlite3_step`, `sqlite3BtreeInsert`, `unixWrite`, and the instruction after its `pwrite64` (found by objdump); every syscall recorded, `-s 4096` | 181 (42 stops, 138 syscalls), 233 KB (139 KB) | made only with `-Dsqlite=DIR` (default `~/05-genizah/sqlite/sqlite-amalgamation-3500400`), in a new temporary directory each time; `sqlite3.c` is embedded as the source |

A recording that begins inside a call (`--from`) has that call open from
its first stop (`Recording.index`, from the frame chain). Writes are the
bytes whose value changed, to the element the instruction stored (its
`touch`); a store of the same value is kept apart (`storedSame`) and
counts as assigning a local (and as a name coming to a node's pin). A register's change over a step is net: a
call's rsp put back is not struck. The vDSO's `clock_gettime` is stepped
through under the runtime and the agent: its retry loop makes the counts
vary a little from one recording to the next, and with a slower stop it
seldom gets out: `list` with `--stack 512` took 27 000 to 42 000 moments,
with 1024 0.3 to 1.6 million (100 MB, minutes), against 3 900 at 256
(`--around` and `--disasm` matter little). So the two instrumented
programs keep `--stack 256` (48 words with the 128 bytes under rsp): their
map's stack column is shorter. The tracer should run through a call into
the vDSO as `step` runs through code without lines. An address no symbol
holds is named from its module's first mapping (`list+2c89`).

## Motion, as measured

`tools/chart.py chart` on the 1080p exports in `out/` (the designer's five
checks; its regions are the working frame's; the minimap, 1664 to 1856 by
912 to 1020, is in none). Encoded with `-g 600`: x264's keyframe at 10,
20, 30 s is a one-frame fade the instrument sees. "Before" is the last
pass's exports; "after" this pass's: the new marks, the stack's row, arcs,
the minimap, the list's map and dive and its loupes, the recordings remade.

| | fib | list | sort | syscalls | zoom | sqlite |
| --- | --- | --- | --- | --- | --- | --- |
| POP, before / after | 0 / 0 | 0 / 0 | 0 / 0 | 0 / 0 | 0 / 0 | 0 / 0 |
| CROWD, before / after | 2 / 2 | 7 / 6 | 5 / 4 | 1 / 1 | 4 / 3 | 0 / 1 |
| RUSH, before / after | 0 / 2 | 2 / 2 | 0 / 0 | 1 / 1 | 0 / 0 | 1 / 2 |
| AIR, before / after | 0 / 0 | 0 / 0 | 0 / 0 | 0 / 0 | 1 / 1 | 5 / 5 |
| seconds, after | 41.5 | 70.9 | 42.0 | 37.9 | 32.0 | 64.6 |

New this pass: list's CROWD at 2.52 is the dive (the windows go bright,
then every panel sets off within 0.5 s: by design one move); fib's RUSH at
5.78 and 7.30 is x264 noise in the caption band (30 pixels changing by 6
to 24 levels under the still caption while the panels move), not a
caption arriving; sqlite's new RUSH at 19.05 is not examined. The rest are
as below.

What fires, and why it is left:

- CROWD: fib 12.05 and 27.20, list 30.62 and 32.18, sort 17.60 are the
  veil coming over the registers, stack and disassembly at the first
  shortened step (one veil over three panels); zoom 9.65 and 21.55 the
  camera (the regions are fixed on the screen); zoom 11.75 the stack's
  window scrolling to its hold under the camera (the stack fills every
  region there); sort 30.00 is x264's keyframe on a step's first frame.
  The rest (list 15.92, 19.32 and the others like them, sort 11.68,
  29.42 and 36.13, syscalls 34.75, zoom 3.62) are an
  `advance`: the thread, the plaques and rip move as one mark, the
  source and the disassembly scroll with it, and a link or projection
  goes back into its pin, all on the catalogue's one frame. (sqlite's,
  the crossing's advance at 43.40, no longer starts with another panel.)
- RUSH: list 29.20 and 29.55, syscalls 29.32, sqlite 9.10: a caption
  arrives, and the next change the instrument sees is the keyframe at
  30.00 (10.00) (a fade of every region over one frame, 0.00% at its
  peak).
- AIR: a caption's reading time on a still picture: the last one's and
  the 2 s on the finished picture (zoom 26.88, 3.1 s; sqlite 60.03,
  4.6 s), and in sqlite four more, each a dense caption over a stop
  (11.38, 7.2 s: the arguments; 24.57, 3.2 s: the two more rows, now
  that a continue is a wave and a 36 f hold and not a cascade's longest
  hold; 32.95, 3.2 s: the commit's backtrace; 50.03, 4.9 s: the page's
  header), its fields framed as it names them.

## What is not done

- The map is packed into fixed places (`map.split`): a panel longer than
  its column is a window of what fits; continuing in the next column's
  free space under `continued`, the key in a column's foot, `memory` in
  a scene without a lens, and loupes as panels on the map (and as lifted
  blocks on the minimap) are not built. The sqlite scene's lenses (the
  backtrace, the kernel's side) and the zoom scene have no drawing on
  their map. A disassembly of 69 rows shows what the recording decoded
  round the pc, so a small function leaves rows empty.
- The minimap draws no thread and no `flash`; its windows are outlined a
  frame behind the panels that publish them after the clock (the lens's
  view). The scene's focus is not set on it.
- `dive`: every panel travels 60 f (the catalogue's 72 f is the map's
  fall), so that seven of them 6 f apart land by 120 f; the drawing does
  not crossfade between sizes (the list's are the same, subject on both);
  panels draw in the scene's order (source, disassembly, registers, stack,
  then the lens), not the reading order, so the stack passes over the
  registers' lower rows, opaque, for about 0.35 s before it lands. Only
  the list opens on the map; no scene surfaces, and no sprint or far
  continue plays on the map.
- A loupe keeps to the stage but does not yet move past the current marks
  or a changed row; on the 1920 stage a deeper loupe has 20, not 120, to
  its right (the stage's edge), and covers most of the first. The
  catalogue's stem is 3 in its strokes and 4 in the loupe's anatomy: it is
  4 here.
- An `arc`'s lane change does not glide (12 f): a lane is given each
  frame from the arcs then present.

- Back pointers between nodes still run under the nodes: a page keyline
  round each pin's stub and head shows them passing behind it (there is
  no lane for them in `beside`).
- An `under` pin's names are in the order they came to the node (the
  recording read back from the stop shown), so a name that lands where
  another is stays on the right it travelled on; but one left alone
  where it was on the right keeps that side only for the step in which
  the other left, and takes the left at the next. A third name coming to
  a pin whose two sides are taken is counted (`+1`), unless it is a
  variable the scene names and a register holds the right, which it then
  takes; on its way it is drawn over the right-hand name (list, 7.5 s).
  A pin's count (`+1`) can run into the left-hand name of the next
  node's pin (list, 26 to 57 s).
  (In the stack's lane,
  rsp or rbp travelling alone keeps its place among the names it leaves
  and joins; both travelling to rows with other names is not handled.)
- Pins travel with `time.pin`'s times, but on `standard`, not the
  catalogue's `glide`, in the stack's lane and the array; a pin in a
  drawing sets off when the idea strikes (the projection's arrival),
  not 18 f after its word's strike.
- The disassembly scrolls or fades over the mark's advance: 24 f where
  the source's window moves too, 12 f where the mark only jumps.
- Whether the stack's window faded at a step is judged by the slots it
  shows now: after a relayout to fewer, a step that scrolled may lose
  its ticks.
- A frame's name on a `call` span is never cut (`metric.span.name_max`,
  300 units, is not built); the calls tree's small and folded sizes are
  not built.
- A link to a slot past the stack's window ends in its stub and row count:
  drawn in the sqlite scene only (rsi to the struct on the caller's
  stack, `23 rows`, 5.0 s; in a continue a link sets off with memory's
  strike, when the window is at its new place). One to a slot above the
  window would put its count over the panel's tag.
- The calls tree's leaf spacing holds for fib(5); past about ten leaves
  nodes and badges collide (the catalogue's known case).
- `heap` and `pages` lenses are not in the band (`Timeline` is the old
  far view).
- A recording holds the bytes it has seen, each as last seen: it cannot
  tell a byte read again and unchanged from one not read since. Memory
  nothing watches (SQLite's page cache) is read at a stop only where a
  pointer leads (32 bytes), so a view of it says what the stop read
  (`hexdump.Fields.seen`); a syscall's buffer is shown as the kernel took
  it, from its capture. The recorder should say what it read at each stop.
- A frame's file and line are known only where the recording stopped in
  it: return addresses are recorded with names, not lines, so a deep
  backtrace's older rows have none.
- A program's frame arguments are in the backtrace only for calls the
  recording tells (an instrumented program's); at a breakpoint the
  callee's are in its registers, which the scene's captions name.
- The sqlite scene changes what is over the band (the backtrace lens,
  then the kernel's side) and its view (the SQL at rbx, the row, the
  page) by fades scripted in the scene (12 f out, then 12 f in); the
  kernel's side does not bring its elements in as at `establish`.
- `zig build test` prints "failed command" for each scripted scene: that
  is the run echoing its stderr (the Vulkan headless warning), not a
  failure; the summary line is the verdict.