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
//! **The window** — the seat's whole reason to exist (yog's `docs/REMOTE.md`
//! §7, §8.2, §9.7; DESIGN §4.11).
//!
//! # The frame renders a snapshot and does nothing else
//!
//! Every function below takes what it is given and paints it. Nothing here
//! dials, reads a file, blocks or waits: a frame that could do any of those is
//! a frame that can freeze, and a frozen window is the one failure a seat has
//! no excuse for. What fills the [`Model`] is [`crate::offframe`], and the
//! frame's whole side of it is one `settle` at the top of an update.
//!
//! The one thing a frame *produces* is [`Model::outbox`]: the gestures a click
//! or a keystroke composed, drained by whoever can send them. A frame that
//! posted its own gesture would be a frame that waits.
//!
//! # It fires through the verb table, not beside it
//!
//! A composed gesture is built by [`crate::verbs`] — the same rows
//! `lernie message` spends. So the window and the command line are two
//! serializations of one surface rather than two spellings of a gesture, which
//! is REMOTE §3's rule read one more time.
//!
//! # Every assertion about this module goes through the paint probe
//!
//! `crate::paint_probe` is the one walk and
//! `rules/no-hand-rolled-paint-walk.yml` is why. A galley reports the string
//! that went IN, so a label the toolkit elided to `…` reads back whole and
//! every assertion against it is blind to truncation. That rule arrived here
//! with this window, as a rule and not as a memory.
/// The `act:<op>` token a control carries so interface drift is catchable.
/// The ball pane: the board, the bindings, and what the aimed wall holds.
/// The chat pane: one conversation, entry by entry.
/// The place a trail is cut in — the second destructive act's own pane.
/// The clients pane: which machines may execute for a wall, and what they offer.
/// The commands pane: every op each engine has a word for, and what each does.
/// The composer: what an operator types, and the gesture it becomes.
/// The config pane: the files a wall's policy is written in, and their settings.
/// A conversation's row under its wall, and the words a row is made of.
/// The doctor pane: whether this box is wired, one row per check.
/// The enrollment pane: a name, a grade, and the symbol that comes back.
/// The find pane: text found across everything these engines can see.
/// The fleet pane: running a wall's balls, watching them, and what they did.
/// The keyboard: every act this window affords, without a pointer.
/// The login pane: what a wall can sign in to, and the act that signs it in.
/// What the window holds between frames, and how a reply becomes part of it.
/// The decision queue: everything waiting on the operator, anywhere.
/// The records pane: what a conversation's loop did, and what it touched.
/// The window's one list: the engines, their walls, and the aimed wall's
/// conversations.
/// The layout, and the notice that stands where content would have been.
/// The ink a row is painted in.
/// The trail pane: every action that crossed an engine's boundary.
/// The tuning pane: what a wall's roles are set to, and what sets them.
/// The unmaking pane: the seat's one destructive act, and the idiom it sets.
pub use ;
pub use ;