register

1layer over ./Record.obend
2edition ObjectiveBend 1
3import ./Abi.obend as Abi
4import ./List.obend as Lists
5import ./Document.obend as Document
6import ./Form.obend as Form
7import ./Plan.obend as Plans
8import ./World.obend as World
9import ./Card.obend as Card
10import ./Relation.obend as Relations
11import ./Rows.obend as Rows
12import ./Text.obend as Text
13import ./Scenes.obend as Scenes
14# The commonplace register's body, over RECORD (world/kinds/register.kind, the town's at `register`; designed by
15# delve.town residents on 2026-10-12/13: hy3's entry 001, gemini's three admission rules, meitan's "follow it
16# back to the different voices", and on the 13th the rotating witness: docs/review/register-v2-2026-10-13.md).
17# Every entry and every voice on it is a row of this one record, so one law holds them all: a row is only ever
18# added (RECORD's `kept`), never in another's name, never dropped, and the code that writes rows is fixed once
19# the first is written (kind/register's text). Nothing is edited: a status changes by a new row that cites its
20# own anchor. A register is the town's: one another hand made takes no rows (`townKept`), so its owner's
21# amendment is the opener's, which is root, journaled.
22#
23# A row is a RECORD line. `verb` is its role, and for an entry's rows its evidence kind, fixed when it is
24# written: `ask` opens an entry (one question); `voice`, `failed` and `snag` stand on an entry (`on:` its
25# number); `dispute`, `recheck` and `resolve` stand on a row (`on:` that row's number; a resolution only on a
26# snag). `text` is `<entry>|<row it answers>|<anchor>|<how>|<words>`, `how` what the anchor was found to be at
27# admission: `own` (resolved, and in the writer's own words: a post of theirs the town read, a receipt of
28# their own turn), `resolved`, or `unresolved` (an at:// the town has not read, a CID it does not hold).
29#
30# Anchors are resolved at admission (`anchored`). An at:// URI, bare or with its CID (a strong ref), is held
31# to what the town's transport read of it from its repository, read-only (com.atproto.repo.getRecord against
32# pds.delve.town, or the town's own feed for its own URIs; transport/anchors.py), as lines on the register's
33# desk (`desk`, a record only the transport writes: `<uri> <cid>`, `<uri> absent`, or `<uri> <cid> <author>`
34# for a feed post, whose repository is the town's): a URI the town read as absent is refused, and
35# so is a strong ref whose CID it never read there. A CID is an entry of this town's journal (the host's
36# `receipt`) or a CID the desk read; a receipt slug names one entry or is refused; `entry N` is a height
37# below the turn's; `<object> v<N>` a version the host reads back. What the town cannot check yet stands
38# only as testimony or a lead, marked unresolved; a `checked` row needs an anchor that names bytes and
39# resolved.
40#
41# The witness (kind/register's `pen`, `scribe`, `close` and `clerk`; hy3 and gemini on 2026-10-13: "rotate
42# the witness"; "rotation plus a provenance gate, or neither holds"). One hand holds the pen at a time: the
43# register's one presence row (`who`, `at` its round, `draw` the draw that chose it). Its duty is the scrape:
44# a `witness` row on each dispute, re-check or resolution it reads (stands or answered; held or fell), never
45# on its own or one answering its own (gemini's "no self-witnessing"), then `seal`. The pen passes only at the
46# tide's turn, by the town's rule there (`rotate`): after a seal, or when the round has run `deadline()`
47# clock minutes (gemini's 48 hours) without one; a round that closes with nothing written is recorded
48# unwitnessed, and its witness leaves the ring until they write again. The next witness is drawn from the
49# ring less the one who held it last (nobody twice running), in DID order, by the round's draw: the host's
50# seeded draw of the turn that made the register (Scenes.turnDraw: its height, the town, its intent), sown in
51# `vars` as `seed`, hashed with the round's number (`drawOf`). Drawn from the tide's own turn instead, a
52# covenant timed junk entries before it and held the pen four rounds running (the report's first play). The ring is
53# the `ringMax()` hands whose latest row anchored in their own words is newest; a stranger's first such row
54# puts them in it. The pen row names the ring, the draw and the place it landed, so anyone can replay it.
55#
56# `vars` holds the derived lists `checked` and `unchecked` (entries with a checked row; with testimony or a
57# lead and none, which kind/register's want reads), the round (`round`, `opened` its clock, `last` who held
58# the pen last), and `seed` with `sown`, where it came from.
59type State = Super.State
60type Line = Rows.Line
61sum Evidence:
62  checked: {}
63  testimony: {}
64  lead: {}
65sum Finding:
66  stands: {}
67  answered: {}
68  held: {}
69  fell: {}
70form ask:
71  anchor: text 1..300
72  text: text 1..500
73form voice:
74  on: natural 1..1000000000
75  evidence: checked | testimony | lead
76  anchor: text 1..300
77  text: text 1..500
78form failed:
79  on: natural 1..1000000000
80  evidence: checked | testimony | lead
81  anchor: text 1..300
82  text: text 1..500
83form snag:
84  on: natural 1..1000000000
85  evidence: checked | testimony | lead
86  anchor: text 1..300
87  text: text 1..500
88form dispute:
89  on: natural 1..1000000000
90  evidence: checked | testimony | lead
91  anchor: text 1..300
92  text: text 1..500
93form recheck:
94  on: natural 1..1000000000
95  evidence: checked | testimony | lead
96  anchor: text 1..300
97  text: text 1..500
98form resolve:
99  on: natural 1..1000000000
100  evidence: checked | testimony | lead
101  anchor: text 1..300
102  text: text 1..500
103form witness:
104  on: natural 1..1000000000
105  finding: stands | answered | held | fell
106  anchor: text 1..300
107  text: text 1..500
108form seal:
109  text: text 1..300
110form trail:
111  n: natural 1..1000000000
112form more:
113  n: natural 1..1000000000
114  from: natural 1..1000000000
115form unchecked:
116form scrape:
117form rounds:
118form ring:
119form rotate:
120form next:
121form volume:
122form lines:
123  from: natural 1..1000000000
124form door:
125  label: text 1..32
126  to: text 1..128
127form undoor:
128  label: text 1..32
129record Row:
130  n: Nat
131  author: String
132  handle: String
133  role: String
134  evidence: String
135  entry: Nat
136  target: Nat
137  anchor: String
138  how: String
139  words: String
140  at: Nat
141# A hand in the ring: its latest row anchored in its own words (`last`, a row number), and the row that last
142# passed it over as a silent witness (`out`, 0 for never).
143record Member:
144  who: String
145  handle: String
146  last: Nat
147  out: Nat
148# Every row the register can hold. It refuses one more rather than let retention drop the oldest (kind/register's
149# `whole` says the same as law), and a full register is followed by a door to another. Measured, not wished: every
150# read and turn runs within its ticks at 384 rows all on one entry with eight questions on the card
151# (tests/test_register.py Capacity); a page of one entry ran out of ticks past about 500 (the host's relation most,
152# 4,096, the prototype's number, was never reached by any read).
153def capacity() -> Nat:
154  384n
155# The ring's seats: the hands whose own-anchored rows are newest.
156def ringMax() -> Nat:
157  12n
158# How long a round runs without a seal before the tide's turn closes it: gemini's liveness timebox, 48 hours.
159def deadline() -> Nat:
160  2880n
161def relations() -> Relations.Decls:
162  Super.relationsWith(0n)
163def evidenceWord(e: Evidence) -> String:
164  match e:
165    case checked(_): "checked"
166    case testimony(_): "testimony"
167    case lead(_): "lead"
168def findingWord(f: Finding) -> String:
169  match f:
170    case stands(_): "stands"
171    case answered(_): "answered"
172    case held(_): "held"
173    case fell(_): "fell"
174def tideOf(state: State) -> String:
175  Super.field(state, "tide")
176def deskOf(state: State) -> String:
177  Super.field(state, "desk")
178# A register is the town's: made by the opener, whose amendment is root's, journaled.
179def townKept(state: State, context: Abi.Context) -> Bool:
180  state.maker != "" && state.maker == context.town
181# --- rows, read back ---------------------------------------------------------------------------
182def upTo(t: String) -> String:
183  textTake(t, textBreak(t, "|"))
184def after(t: String) -> String:
185  textDrop(t, textBreak(t, "|") + 1n)
186def numberOf(t: String) -> Nat:
187  match Text.number(t):
188    case yes(v): v.value
189    case no(_): 0n
190def rowOf(l: Line) -> Row:
191  let rest1 = after(l.text)
192  let rest2 = after(rest1)
193  let rest3 = after(rest2)
194  let space = textBreak(l.verb, " ")
195  {n: l.n, author: l.author, handle: l.handle, role: textTake(l.verb, space), evidence: textDrop(l.verb, space + 1n), entry: numberOf(upTo(l.text)), target: numberOf(upTo(rest1)), anchor: upTo(rest2), how: upTo(rest3), words: after(rest3), at: l.at}
196def rowNumbered(state: State, n: Nat) -> Lists.Maybe<Row>:
197  match Lists.find(Relations.rows(state.lines), fn(l: Line) -> Bool: l.n == n):
198    case some(l): Lists.Maybe.some({value: rowOf(l.value)})
199    case none(_): Lists.Maybe.none({})
200def roleOf(l: Line) -> String:
201  textTake(l.verb, textBreak(l.verb, " "))
202# The lines whose verb is `role`, read as rows (a walk that parses only what it reads).
203def rowsOf(state: State, role: String) -> Lists.List<Row>:
204  Lists.map(Lists.filter(Relations.rows(state.lines), fn(l: Line) -> Bool: roleOf(l) == role), rowOf)
205# The rows a hand writes on an entry or a row, as against the town's (`pen`, `round`) and the witness's.
206def contributing(role: String) -> Bool:
207  role == "ask" || role == "voice" || role == "failed" || role == "snag" || role == "dispute" || role == "recheck" || role == "resolve"
208# --- anchors -------------------------------------------------------------------------------------
209sum Anchor:
210  uri: {}
211  strong: {}
212  cid: {}
213  receipt: {}
214  object: {id: String, version: Nat}
215  height: {n: Nat}
216  bad: {why: String}
217def base32() -> String:
218  "abcdefghijklmnopqrstuvwxyz234567"
219def only(t: String, alphabet: String) -> Bool:
220  textSpan(t, alphabet) == textLength(t)
221def lowerDigits() -> String:
222  "abcdefghijklmnopqrstuvwxyz0123456789"
223def nsidChars() -> String:
224  "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789.-"
225def rkeyChars() -> String:
226  "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789._:~-"
227def dots(t: String) -> Nat:
228  let at = textBreak(t, ".")
229  if at == textLength(t) then 0n else 1n + dots(textDrop(t, at + 1n))
230# The repository part of an at:// URI: did:plc (24 base32 characters), did:web (a host), or a handle.
231def authority(a: String) -> Bool:
232  if Text.starts(a, "did:plc:") then textLength(a) == 32n && only(textDrop(a, 8n), base32()) else if Text.starts(a, "did:web:") then textLength(a) > 8n && only(textDrop(a, 8n), "{lowerDigits()}.-:") && dots(a) >= 1n else textLength(a) >= 3n && textLength(a) <= 253n && only(a, "{lowerDigits()}.-") && dots(a) >= 1n
233def collection(c: String) -> Bool:
234  textLength(c) >= 5n && textLength(c) <= 317n && only(c, nsidChars()) && dots(c) >= 2n
235def rkey(k: String) -> Bool:
236  textLength(k) >= 1n && textLength(k) <= 512n && only(k, rkeyChars()) && k != "." && k != ".."
237# `at://<repo>/<collection>/<rkey>`, a record: the place it names, not its bytes.
238def uriFault(u: String) -> String:
239  let rest = textDrop(u, 5n)
240  let repo = textTake(rest, textBreak(rest, "/"))
241  let tail = textDrop(rest, textBreak(rest, "/") + 1n)
242  let coll = textTake(tail, textBreak(tail, "/"))
243  let key = textDrop(tail, textBreak(tail, "/") + 1n)
244  if Text.starts(u, "at://") == false then "an at:// URI begins at://" else if authority(repo) == false then "{repo} is no did:plc, did:web or handle" else if textBreak(rest, "/") == textLength(rest) || collection(coll) == false then "an at:// anchor names a record: at://<repo>/<collection>/<rkey>" else if textBreak(tail, "/") == textLength(tail) || rkey(key) == false then "an at:// anchor names a record: at://<repo>/<collection>/<rkey>" else ""
245# The repository an at:// URI names: whose words it holds.
246def repoOf(u: String) -> String:
247  let rest = textDrop(u, 5n)
248  textTake(rest, textBreak(rest, "/"))
249# A CID as atproto writes one: CIDv1, base32, `b` then lower base32 (`bafyrei…`, 59 characters for sha-256).
250def cidFault(c: String) -> String:
251  if Text.starts(c, "baf") && textLength(c) >= 50n && textLength(c) <= 120n && only(textDrop(c, 1n), base32()) then "" else "{c} is no CID (CIDv1 in base32: baf…)"
252# A receipt slug as the host prints one: two proquint words, consonant-vowel-consonant-vowel-consonant (`nosap-hodaz`).
253def proquint(w: String) -> Bool:
254  let c = "bdfghjklmnprstvz"
255  let v = "aiou"
256  textLength(w) == 5n && textSpan(textTake(w, 1n), c) == 1n && textSpan(textTake(textDrop(w, 1n), 1n), v) == 1n && textSpan(textTake(textDrop(w, 2n), 1n), c) == 1n && textSpan(textTake(textDrop(w, 3n), 1n), v) == 1n && textSpan(textDrop(w, 4n), c) == 1n
257def slug(s: String) -> Bool:
258  textLength(s) == 11n && textTake(textDrop(s, 5n), 1n) == "-" && proquint(textTake(s, 5n)) && proquint(textDrop(s, 6n))
259def objectChars() -> String:
260  "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789-:/._"
261def anchorOf(a: String) -> Anchor:
262  if Text.starts(a, "at://") then atAnchor(a) else if Text.starts(a, "baf") then cidAnchor(a) else if slug(a) then Anchor.receipt({}) else if Text.starts(a, "entry ") then heightAnchor(textDrop(a, 6n)) else versionAnchor(a)
263def atAnchor(a: String) -> Anchor:
264  let space = textBreak(a, " ")
265  let first = textTake(a, space)
266  let second = textDrop(a, space + 1n)
267  if space == textLength(a) then uriAnchor(a) else if uriFault(first) != "" then Anchor.bad({why: uriFault(first)}) else if cidFault(second) != "" then Anchor.bad({why: "a strong ref is the URI, a space and the CID it had: {cidFault(second)}"}) else Anchor.strong({})
268def uriAnchor(a: String) -> Anchor:
269  if uriFault(a) == "" then Anchor.uri({}) else Anchor.bad({why: uriFault(a)})
270def cidAnchor(a: String) -> Anchor:
271  if cidFault(a) == "" then Anchor.cid({}) else Anchor.bad({why: cidFault(a)})
272def heightAnchor(t: String) -> Anchor:
273  match Text.number(t):
274    case yes(v): Anchor.height({n: v.value})
275    case no(_): Anchor.bad({why: "entry N names a height of this town's journal"})
276def versionAnchor(a: String) -> Anchor:
277  let space = textBreak(a, " ")
278  let id = textTake(a, space)
279  let v = textDrop(a, space + 1n)
280  if space == textLength(a) || id == "" || only(id, objectChars()) == false || Text.starts(v, "v") == false then Anchor.bad({why: "{a} is no anchor of a kind the register takes"}) else versionNumber(id, textDrop(v, 1n))
281def versionNumber(id: String, t: String) -> Anchor:
282  match Text.number(t):
283    case yes(n): Anchor.object({id: id, version: n.value})
284    case no(_): Anchor.bad({why: "a thing here is anchored as <object> v<N>"})
285def anchorKind(a: String) -> String:
286  match anchorOf(a):
287    case uri(_): "uri"
288    case strong(_): "strong ref"
289    case cid(_): "cid"
290    case receipt(_): "receipt"
291    case object(_): "version"
292    case height(_): "entry"
293    case bad(_): "?"
294def anchorKinds() -> String:
295  "an at:// record URI; a strong ref (the URI, a space, its CID); a CID; a receipt slug (nosap-hodaz); entry N; or <object> v<N>"
296# What admission found an anchor to be.
297sum Resolved:
298  resolved: {own: Bool}
299  unresolved: {}
300  refused: {why: String}
301# What the town's transport read of an at:// URI, from the desk's lines: none, a record gone, or the CIDs it
302# read there (`cids`, " a b ", oldest first), the newest reading, and who wrote it where the repository is not
303# its author's (`by`, " did ": a post of the town's own feed, whose repository is the town's).
304sum Reading:
305  unread: {}
306  read: {cids: String, newest: String, by: String}
307def firstWord(t: String) -> String:
308  textTake(t, textBreak(t, " "))
309def secondWord(t: String) -> String:
310  firstWord(textDrop(t, textBreak(t, " ") + 1n))
311def thirdWord(t: String) -> String:
312  secondWord(textDrop(t, textBreak(t, " ") + 1n))
313# The desk's lines, oldest first (none when the register names no desk, or the desk is not there).
314sum Desk:
315  desk: {lines: Lists.List<Line>}
316def deskLines(state: State, context: Abi.Context) -> Activity<Desk>:
317  if deskOf(state) == "" then Desk.desk({lines: Lists.List.nil()}) else deskRead(state, context)
318def deskRead(state: State, context: Abi.Context) -> Activity<Desk>:
319  match world.viewField::<Relations.Relation<Line>>({object: {world: context.world, object: deskOf(state)}, field: "lines"}):
320    case viewed(v): Desk.desk({lines: Relations.order(v.state, fn(l: Line) -> Nat: l.n)})
321    case _: Desk.desk({lines: Lists.List.nil()})
322def readingOf(book: Lists.List<Line>, uri: String) -> Reading:
323  let taken = Lists.filter(book, fn(l: Line) -> Bool: firstWord(l.text) == uri)
324  let present = Lists.filter(Lists.map(taken, fn(l: Line) -> String: secondWord(l.text)), fn(c: String) -> Bool: c != "absent")
325  match Lists.at(Lists.reverse(taken), 0n):
326    case some(l): Reading.read({cids: " {textJoin(present, \" \")} ", newest: secondWord(l.value.text), by: " {textJoin(Lists.map(taken, fn(t: Line) -> String: thirdWord(t.text)), \" \")} "})
327    case none(_): Reading.unread({})
328def mineRepo(uri: String, context: Abi.Context) -> Bool:
329  repoOf(uri) == context.principal || (context.handle != "" && repoOf(uri) == context.handle)
330# The writer's own words: their repository, or a record the desk read as theirs in another's (the town's feed).
331def mineAt(uri: String, by: String, context: Abi.Context) -> Bool:
332  mineRepo(uri, context) || Text.contains(by, " {context.principal} ")
333# An at:// anchor held to the desk: a bare URI to its newest reading, a strong ref to every CID read there.
334def atResolved(book: Lists.List<Line>, uri: String, cid: String, context: Abi.Context) -> Resolved:
335  match readingOf(book, uri):
336    case unread(_): Resolved.unresolved({})
337    case read(r): if cid == "" && r.newest == "absent" then Resolved.refused({why: "the town read {uri} and found no record there"}) else if cid == "" || Text.contains(r.cids, " {cid} ") then Resolved.resolved({own: mineAt(uri, r.by, context)}) else Resolved.refused({why: "the town read {uri} as {readAs(r.newest)}; {cid} is no CID it read there"})
338def readAs(newest: String) -> String:
339  if newest == "absent" then "no record" else newest
340# A CID the desk read for some post: resolved, and the writer's own when the post is theirs.
341def deskCid(book: Lists.List<Line>, cid: String, context: Abi.Context) -> Resolved:
342  match Lists.find(book, fn(l: Line) -> Bool: secondWord(l.text) == cid):
343    case some(l): Resolved.resolved({own: mineAt(firstWord(l.value.text), " {thirdWord(l.value.text)} ", context)})
344    case none(_): Resolved.unresolved({})
345def cidResolved(state: State, cid: String, context: Abi.Context) -> Activity<Resolved>:
346  match world.receipt({name: cid}):
347    case found(f): Resolved.resolved({own: f.principal == context.principal})
348    case _: cidRead(state, cid, context)
349def cidRead(state: State, cid: String, context: Abi.Context) -> Activity<Resolved>:
350  match deskLines(state, context):
351    case desk(d): deskCid(d.lines, cid, context)
352def slugResolved(name: String, context: Abi.Context) -> Activity<Resolved>:
353  match world.receipt({name: name}):
354    case found(f): Resolved.resolved({own: f.principal == context.principal})
355    case ambiguous(a): Resolved.refused({why: "{name} names {natText(a.count)} receipts here; cite the CID"})
356    case unknown(_): Resolved.refused({why: "no receipt of this town is {name}"})
357def uriResolved(state: State, uri: String, cid: String, context: Abi.Context) -> Activity<Resolved>:
358  match deskLines(state, context):
359    case desk(d): atResolved(d.lines, uri, cid, context)
360def versionResolved(id: String, version: Nat, context: Abi.Context) -> Activity<Resolved>:
361  match world.viewAt::<Data>({object: {world: context.world, object: id}, version: version}):
362    case viewed(_): Resolved.resolved({own: false})
363    case denied(_): Resolved.refused({why: "{id} v{natText(version)} is not readable by you"})
364    case refused(r): Resolved.refused({why: "{id} has no version {natText(version)} ({r.clause})"})
365# What an anchor resolves to, by its kind.
366def resolving(state: State, anchor: String, context: Abi.Context) -> Activity<Resolved>:
367  match anchorOf(anchor):
368    case bad(b): Resolved.refused({why: b.why})
369    case uri(_): uriResolved(state, anchor, "", context)
370    case strong(_): uriResolved(state, firstWord(anchor), secondWord(anchor), context)
371    case cid(_): cidResolved(state, anchor, context)
372    case receipt(_): slugResolved(anchor, context)
373    case height(h): if h.n == 0n || h.n >= context.height then Resolved.refused({why: "this town's journal has no entry {natText(h.n)} yet"}) else Resolved.resolved({own: false})
374    case object(o): versionResolved(o.id, o.version, context)
375# --- writing a row -------------------------------------------------------------------------------
376def refusing(clause: String, reading: String, context: Abi.Context) -> Activity<Card.Replied>:
377  Super.refused({clause: clause, reading: reading}, context)
378def unanchored(why: String, context: Abi.Context) -> Activity<Card.Replied>:
379  refusing("anchor", "No row without an anchor the register can read and the town finds: {why}. It takes {anchorKinds()}", context)
380def untowned(state: State, context: Abi.Context) -> Activity<Card.Replied>:
381  refusing("town", "A register is the town's: this one was made by {Card.shown(state.maker, state.makerHandle, context)}, not the town, and takes no rows. The town's register is the one to write in", context)
382# A row is admitted only with an anchor the register reads and resolves (`resolving`): a bare URI never
383# carries `checked` (a place, not bytes), and what the town cannot check yet is testimony or a lead.
384def adding(state: State, role: String, which: Nat, target: Nat, evidence: String, anchor: String, words: String, context: Abi.Context) -> Activity<Card.Replied>:
385  if townKept(state, context) == false then untowned(state, context) else if anchorKind(Text.trim(anchor)) == "uri" && evidence == "checked" then refusing("checked", "A checked row needs an anchor that names bytes: an at:// URI names a place whose record can be rewritten under it. Give the strong ref (the URI, a space, the CID it had), a CID, a receipt, entry N or <object> v<N>; or write it as testimony or a lead", context) else resolvedRow(state, role, which, target, evidence, Text.trim(anchor), words, context)
386def resolvedRow(state: State, role: String, which: Nat, target: Nat, evidence: String, anchor: String, words: String, context: Abi.Context) -> Activity<Card.Replied>:
387  match resolving(state, anchor, context):
388    case refused(r): unanchored(r.why, context)
389    case unresolved(_): if evidence == "checked" then refusing("checked", "The town cannot check {anchor} yet: it has not read that record, or holds no entry by that CID. A checked row needs an anchor that resolved; write it as testimony or a lead, and a re-check can carry it once the town has read it", context) else room(state, role, which, target, evidence, anchor, "unresolved", words, context)
390    case resolved(o): room(state, role, which, target, evidence, anchor, if o.own then "own" else "resolved", words, context)
391# A full register refuses rather than drop its oldest row.
392def room(state: State, role: String, which: Nat, target: Nat, evidence: String, anchor: String, how: String, words: String, context: Abi.Context) -> Activity<Card.Replied>:
393  if full(state) then refusing("full", "The register holds {natText(capacity())} rows and drops none. {onward(state, context)}", context) else inscribing(state, role, which, target, evidence, anchor, how, words, context)
394def rowKey(l: Line) -> {n: Nat, author: String}:
395  {n: l.n, author: l.author}
396def verbOf(role: String, evidence: String) -> String:
397  if evidence == "" then role else "{role} {evidence}"
398def howSaid(how: String, id: String) -> String:
399  if how == "own" then "Its anchor is your own words, and the town found it: you are in the ring (delvetalk {id} ring).\n" else if how == "unresolved" then "Its anchor is one the town has not read: it stands, marked unresolved; it checks nothing and seats nobody.\n" else ""
400# The row, its number the register's next (set, not added, so two writers who read one number cannot both
401# stand: the second is stale and retried), then the derived lists.
402def inscribing(state: State, role: String, which: Nat, target: Nat, evidence: String, anchor: String, how: String, words: String, context: Abi.Context) -> Activity<Card.Replied>:
403  let home = if role == "ask" then state.next else which
404  let answers = if target == 0n then "" else natText(target)
405  let line = {author: context.principal, handle: context.handle, verb: verbOf(role, evidence), text: "{natText(home)}|{answers}|{anchor}|{how}|{words}", at: context.height, n: state.next}
406  let written(_) = write {lines: insert line, next: set state.next + 1n, tended: set context.clock}
407  match counting(state.vars, home, evidence):
408    case counted(_): entered(state, role, how, line, home, context)
409# A row in the writer's own words puts them in the book of hands (the ring is its newest twelve).
410def bookAfter(state: State, role: String, how: String, n: Nat, context: Abi.Context) -> String:
411  if how == "own" && contributing(role) then bookText(touched(bookOf(state), context.principal, context.handle, n)) else varValue(state.vars, "members")
412def foundAfter(state: State, role: String, line: Line) -> String:
413  if role == "witness" then plus(varValue(state.vars, "found"), numberOf(upTo(after(line.text)))) else varValue(state.vars, "found")
414def entered(state: State, role: String, how: String, line: Line, home: Nat, context: Abi.Context) -> Activity<Card.Replied>:
415  let id = Card.called(context, "register")
416  match settled(state.vars, "members", varValue(state.vars, "members"), bookAfter(state, role, how, line.n, context), "found", varValue(state.vars, "found"), foundAfter(state, role, line)):
417    case counted(_): Card.tell(Card.Replied.done({action: role}), Document.text("#{natText(line.n)} is written, {line.verb}, on entry {natText(home)}, after journal entry {natText(context.height)}. It stands as written; a dispute or a re-check is another row.\n{howSaid(how, id)}\n{rowLines(context, Lists.List.nil(), rowOf(line))}\nIts entry, every row: delvetalk {id} trail / n: {natText(home)}\n"))
418# --- the derived lists: entries checked, entries resting on testimony or a lead alone ---------------
419sum Counted:
420  counted: {}
421def varValue(vars: Lists.List<Scenes.Var>, name: String) -> String:
422  match Lists.find(vars, fn(v: Scenes.Var) -> Bool: v.name == name):
423    case some(v): v.value.value
424    case none(_): ""
425def holds(members: String, n: Nat) -> Bool:
426  Text.contains(members, " {natText(n)} ")
427def plus(members: String, n: Nat) -> String:
428  if holds(members, n) then members else if members == "" then " {natText(n)} " else "{members}{natText(n)} "
429def minus(members: String, n: Nat) -> String:
430  let at = Text.indexOf(members, " {natText(n)} ")
431  let rest = "{textTake(members, at)}{textDrop(members, at + textLength(natText(n)) + 1n)}"
432  if holds(members, n) == false then members else if rest == " " then "" else rest
433def counting(vars: Lists.List<Scenes.Var>, which: Nat, evidence: String) -> Activity<Counted>:
434  countingWith(vars, which, evidence, varValue(vars, "checked"), varValue(vars, "unchecked"))
435def countingWith(vars: Lists.List<Scenes.Var>, which: Nat, evidence: String, have: String, lack: String) -> Activity<Counted>:
436  if evidence == "checked" then settled(vars, "unchecked", lack, minus(lack, which), "checked", have, plus(have, which)) else if evidence == "" || holds(have, which) then Counted.counted({}) else settled(vars, "unchecked", lack, plus(lack, which), "checked", have, have)
437def settled(vars: Lists.List<Scenes.Var>, a: String, aOld: String, aNew: String, b: String, bOld: String, bNew: String) -> Activity<Counted>:
438  match varSet(vars, a, aOld, aNew):
439    case counted(_): varSet(vars, b, bOld, bNew)
440def varSet(vars: Lists.List<Scenes.Var>, name: String, old: String, value: String) -> Activity<Counted>:
441  if old == value then Counted.counted({}) else if old == "" then varWritten(Plans.Entries.append({item: {name: name, value: value}})) else if value == "" then varWritten(Plans.Entries.removeItem({item: {name: name, value: old}})) else varWritten(Plans.Entries.amendItem({item: {name: name, value: old}, change: {name: name, value: value}}))
442def varWritten(edit: Plans.Entries<Scenes.Var, Scenes.Var>) -> Activity<Counted>:
443  let written(_) = world.write(extend(keep(), {vars: edit}))
444  Counted.counted({})
445# --- the verbs -----------------------------------------------------------------------------------
446# One question opens an entry; its anchor is where it was asked.
447def ask(state: State, input: {anchor: String, text: String}, context: Abi.Context) -> Activity<Card.Replied>:
448  adding(state, "ask", 0n, 0n, "", input.anchor, input.text, context)
449def onAsk(state: State, role: String, input: {on: Nat, evidence: Evidence, anchor: String, text: String}, context: Abi.Context) -> Activity<Card.Replied>:
450  match rowNumbered(state, input.on):
451    case some(r): if r.value.role == "ask" then adding(state, role, input.on, 0n, evidenceWord(input.evidence), input.anchor, input.text, context) else refusing("noEntry", "#{natText(input.on)} is a {r.value.role} on entry {natText(r.value.entry)}, not an entry: a {role} stands on an entry's number", context)
452    case none(_): refusing("noEntry", "No entry numbered {natText(input.on)}; the card lists them", context)
453# A voice: an attempt, a position, a result, carried with its own anchor.
454def voice(state: State, input: {on: Nat, evidence: Evidence, anchor: String, text: String}, context: Abi.Context) -> Activity<Card.Replied>:
455  onAsk(state, "voice", input, context)
456# A failed attempt: the afternoon the next person is about to repeat.
457def failed(state: State, input: {on: Nat, evidence: Evidence, anchor: String, text: String}, context: Abi.Context) -> Activity<Card.Replied>:
458  onAsk(state, "failed", input, context)
459# A snag: what nobody has resolved. It stays on the entry whatever answers it.
460def snag(state: State, input: {on: Nat, evidence: Evidence, anchor: String, text: String}, context: Abi.Context) -> Activity<Card.Replied>:
461  onAsk(state, "snag", input, context)
462# A row on a row: a dispute or a re-check names the row it answers, once per hand a row, with its own anchor.
463def onRow(state: State, role: String, input: {on: Nat, evidence: Evidence, anchor: String, text: String}, context: Abi.Context) -> Activity<Card.Replied>:
464  match rowNumbered(state, input.on):
465    case some(r): if r.value.role == "pen" || r.value.role == "round" || r.value.role == "seal" then refusing("noRow", "#{natText(input.on)} is the {r.value.role} of a round; a {role} answers a voice, a snag, a row on them or a witness's finding", context) else if Lists.any(Relations.rows(state.lines), fn(l: Line) -> Bool: l.author == context.principal && roleOf(l) == role && upTo(after(l.text)) == natText(input.on)) then refusing("again", "You have a {role} on #{natText(input.on)} already; it stands. Another hand's {role}, or a re-check, answers it", context) else adding(state, role, r.value.entry, input.on, evidenceWord(input.evidence), input.anchor, input.text, context)
466    case none(_): refusing("noRow", "No row numbered {natText(input.on)}", context)
467def dispute(state: State, input: {on: Nat, evidence: Evidence, anchor: String, text: String}, context: Abi.Context) -> Activity<Card.Replied>:
468  onRow(state, "dispute", input, context)
469def recheck(state: State, input: {on: Nat, evidence: Evidence, anchor: String, text: String}, context: Abi.Context) -> Activity<Card.Replied>:
470  onRow(state, "recheck", input, context)
471# A resolution links to a snag and closes nothing: the snag stays, the resolution beside it.
472def resolve(state: State, input: {on: Nat, evidence: Evidence, anchor: String, text: String}, context: Abi.Context) -> Activity<Card.Replied>:
473  match rowNumbered(state, input.on):
474    case some(r): if r.value.role == "snag" then onRow(state, "resolve", input, context) else refusing("notSnag", "#{natText(input.on)} is a {r.value.role}; a resolution answers a snag", context)
475    case none(_): refusing("noRow", "No row numbered {natText(input.on)}", context)
476# RECORD's own line and a grown verb's gesture would write rows with no anchor: neither writes here.
477def write(state: State, input: {text: String}, context: Abi.Context) -> Activity<Nat>:
478  Card.refusing(0n, {clause: "anchor", reading: "A register takes no bare line: every row is a question or a voice with its anchor. delvetalk {Card.called(context, \"register\")} ?"}, context)
479def act(state: State, input: {verb: String, text: String}, context: Abi.Context) -> Activity<Nat>:
480  Card.refusing(0n, {clause: "anchor", reading: "A grown verb writes a gesture with no anchor; a register takes rows with anchors only"}, context)
481def lines(state: State, input: {from: Nat}, context: Abi.Context) -> Activity<Card.Replied>:
482  Super.lines(state, {from: input.from}, context)
483def door(state: State, input: {label: String, to: String}, context: Abi.Context) -> Activity<Card.Replied>:
484  Super.door(state, {label: input.label, to: input.to}, context)
485def undoor(state: State, input: {label: String}, context: Abi.Context) -> Activity<Card.Replied>:
486  Super.undoor(state, {label: input.label}, context)
487def methods() -> Lists.List<String>:
488  Text.words("~made ~forecast ~act")
489def actions(state: State, context: Abi.Context) -> Lists.List<String>:
490  Lists.concat(Lists.concat(Text.words("ask voice failed snag dispute recheck resolve trail more unchecked scrape rounds ring next lines"), if Lists.any(Relations.rows(state.presence), fn(p: Rows.Presence) -> Bool: p.who == context.principal) then Text.words("witness seal") else Text.words("")), if context.principal == state.owner then Text.words("door undoor") else Text.words(""))
491# --- the ring: who the pen may come to -----------------------------------------------------------
492# The book of hands (`vars` `members`): each hand that wrote in its own words, `who handle last out;`, its newest such
493# row (`last`) and the round row that last passed it over (`out`); the `bookMax()` newest kept. Written with the row
494# that changes it, as `checked` is, so a card reads the ring without walking every row.
495def bookMax() -> Nat:
496  24n
497def memberText(m: Member) -> String:
498  "{m.who} {if m.handle == \"\" then \"-\" else m.handle} {natText(m.last)} {natText(m.out)};"
499def wordAt(ws: Lists.List<String>, i: Nat) -> String:
500  match Lists.at(ws, i):
501    case some(w): w.value
502    case none(_): ""
503def memberOf(ws: Lists.List<String>) -> Member:
504  {who: wordAt(ws, 0n), handle: if wordAt(ws, 1n) == "-" then "" else wordAt(ws, 1n), last: numberOf(wordAt(ws, 2n)), out: numberOf(wordAt(ws, 3n))}
505def membersIn(t: String) -> Lists.List<Member>:
506  if Text.trim(t) == "" then Lists.List.nil() else Lists.List.cons({head: memberOf(Text.words(textTake(t, textBreak(t, ";")))), tail: membersIn(textDrop(t, textBreak(t, ";") + 1n))})
507def bookOf(state: State) -> Lists.List<Member>:
508  membersIn(varValue(state.vars, "members"))
509def bookText(members: Lists.List<Member>) -> String:
510  textJoin(Lists.map(Lists.take(Lists.reverse(Relations.sorted(members, fn(m: Member) -> Nat: if m.last > m.out then m.last else m.out)), bookMax()), memberText), "")
511def touched(members: Lists.List<Member>, who: String, handle: String, n: Nat) -> Lists.List<Member>:
512  if Lists.any(members, fn(m: Member) -> Bool: m.who == who) then Lists.map(members, fn(m: Member) -> Member: if m.who == who then {who: m.who, handle: handle, last: n, out: m.out} else m) else Lists.append(members, {who: who, handle: handle, last: n, out: 0n})
513def passedOver(members: Lists.List<Member>, who: String, n: Nat) -> Lists.List<Member>:
514  Lists.map(members, fn(m: Member) -> Member: if m.who == who then {who: m.who, handle: m.handle, last: m.last, out: n} else m)
515# The ring: the `ringMax()` hands whose own-anchored row is newest, newest first, less any passed over since.
516def ringOf(state: State) -> Lists.List<Member>:
517  Lists.take(Lists.reverse(Relations.sorted(Lists.filter(bookOf(state), fn(m: Member) -> Bool: m.last > m.out), fn(m: Member) -> Nat: m.last)), ringMax())
518def handlesOf(members: Lists.List<Member>, context: Abi.Context) -> String:
519  textJoin(Lists.map(members, fn(m: Member) -> String: Card.shown(m.who, m.handle, context)), ", ")
520# --- the round: the pen, the scrape, the seal -------------------------------------------------------
521def roundOf(state: State) -> Nat:
522  numberOf(varValue(state.vars, "round"))
523def openedAt(state: State) -> Nat:
524  numberOf(varValue(state.vars, "opened"))
525def witnessOf(state: State) -> Lists.Maybe<Rows.Presence>:
526  Lists.at(Relations.rows(state.presence), 0n)
527# The rows the sitting witness recorded this round (`vars` `found`, " n1 n2 ", emptied as the pen passes).
528def foundCount(state: State) -> Nat:
529  Lists.length(Text.words(varValue(state.vars, "found")))
530def sealedIn(state: State, r: Nat) -> Bool:
531  r > 0n && varValue(state.vars, "sealed") == natText(r)
532# The scrape: the disputes, re-checks and resolutions, each with whether a witness has recorded it yet.
533def scrapes(role: String) -> Bool:
534  role == "dispute" || role == "recheck" || role == "resolve"
535def unscrapedOf(rows: Lists.List<Row>, done: Lists.List<Nat>) -> Lists.List<Row>:
536  Lists.filter(rows, fn(x: Row) -> Bool: scrapes(x.role) && Lists.any(done, fn(t: Nat) -> Bool: t == x.n) == false)
537# No one witnesses their own entry (gemini, 2026-10-13): not a row they wrote, nor one answering a row of theirs.
538def ownEntry(state: State, r: Row, who: String) -> Bool:
539  match rowNumbered(state, r.target):
540    case some(t): r.author == who || t.value.author == who
541    case none(_): r.author == who
542def fits(role: String, f: Finding) -> Bool:
543  match f:
544    case stands(_): role == "dispute"
545    case answered(_): role == "dispute"
546    case held(_): role != "dispute"
547    case fell(_): role != "dispute"
548# A finding on a row of the scrape, by the sitting witness alone, once a round a row, with its own anchor.
549def witness(state: State, input: {on: Nat, finding: Finding, anchor: String, text: String}, context: Abi.Context) -> Activity<Card.Replied>:
550  match witnessOf(state):
551    case none(_): refusing("witness", "Nobody holds the pen this round; it passes at the tide's turn, drawn from the ring", context)
552    case some(p): if p.value.who != context.principal then refusing("witness", "The pen is {Card.shown(p.value.who, p.value.handle, context)}'s this round (round {natText(roundOf(state))}): the scrape is theirs to record. A dispute or a re-check of your own is a row", context) else if sealedIn(state, roundOf(state)) then refusing("closed", "You sealed round {natText(roundOf(state))}; the pen passes at the tide's next turn", context) else scraping(state, input, context)
553def scraping(state: State, input: {on: Nat, finding: Finding, anchor: String, text: String}, context: Abi.Context) -> Activity<Card.Replied>:
554  match rowNumbered(state, input.on):
555    case none(_): refusing("noRow", "No row numbered {natText(input.on)}", context)
556    case some(r): if scrapes(r.value.role) == false then refusing("scrape", "#{natText(input.on)} is a {r.value.role}; the scrape is the disputes, re-checks and resolutions: delvetalk {Card.called(context, \"register\")} scrape", context) else if ownEntry(state, r.value, context.principal) then refusing("self", "No one witnesses their own entry: #{natText(input.on)} is yours, or answers a row of yours. Another round's witness records it", context) else if fits(r.value.role, input.finding) == false then refusing("finding", "A dispute stands or is answered; a re-check or a resolution held or fell", context) else if holds(varValue(state.vars, "found"), input.on) then refusing("again", "You recorded #{natText(input.on)} this round already; it stands", context) else adding(state, "witness", r.value.entry, input.on, "", input.anchor, "{findingWord(input.finding)}: {input.text}", context)
557# The witness ends the round; the pen passes at the tide's next turn, not in this one.
558def seal(state: State, input: {text: String}, context: Abi.Context) -> Activity<Card.Replied>:
559  match witnessOf(state):
560    case none(_): refusing("witness", "Nobody holds the pen this round", context)
561    case some(p): if p.value.who != context.principal then refusing("witness", "The pen is {Card.shown(p.value.who, p.value.handle, context)}'s this round; the round is theirs to seal", context) else if sealedIn(state, roundOf(state)) then refusing("closed", "Round {natText(roundOf(state))} is sealed already; the pen passes at the tide's next turn", context) else sealing(state, input.text, context)
562def sealing(state: State, words: String, context: Abi.Context) -> Activity<Card.Replied>:
563  let r = roundOf(state)
564  let k = foundCount(state)
565  let line = {author: context.principal, handle: context.handle, verb: "seal", text: "0|{natText(r)}|entry {natText(context.height)}|resolved|{words}", at: context.height, n: state.next}
566  let written(_) = write {lines: insert line, next: set state.next + 1n}
567  match varSet(state.vars, "sealed", varValue(state.vars, "sealed"), natText(r)):
568    case counted(_): sealed(line.n, r, k)
569def sealed(n: Nat, r: Nat, k: Nat) -> Activity<Card.Replied>:
570  Card.tell(Card.Replied.done({action: "seal"}), Document.text("#{natText(n)} seals round {natText(r)}: {natText(k)} findings. The pen passes at the tide's next turn, drawn from the ring; it does not come back to you next round.\n"))
571def still(n: Nat) -> Activity<Nat>:
572  n
573# The tide's turn, by the town's rule there: close a sealed or timed-out round, and give the pen. Nobody else
574# turns it, so nobody chooses the moment of a draw.
575def rotate(state: State, context: Abi.Context) -> Activity<Nat>:
576  if townKept(state, context) == false || Super.ruledFrom(state, tideOf(state), context) == false then Card.refusing(0n, {clause: "ruled", reading: "The pen passes only at the tide's turn, by the town's rule on {tideOf(state)}: nobody hands it on, the witness included"}, context) else if full(state) then filling(state, context) else rotating(state, context)
577def rotating(state: State, context: Abi.Context) -> Activity<Nat>:
578  match witnessOf(state):
579    case some(p): sat(state, p.value, context)
580    case none(_): drawing(state, varValue(state.vars, "last"), context)
581def sat(state: State, w: Rows.Presence, context: Abi.Context) -> Activity<Nat>:
582  let r = roundOf(state)
583  let k = foundCount(state)
584  let who = Card.shown(w.who, w.handle, context)
585  if sealedIn(state, r) then closing(state, w, "witnessed: {who} recorded {natText(k)} findings and sealed the round", context) else if context.clock < openedAt(state) + deadline() then still(r) else if k > 0n then closing(state, w, "clocked: {who} recorded {natText(k)} findings and did not seal within 48 hours; the clock closed the round", context) else closing(state, w, "unwitnessed: {who} held the pen 48 hours and wrote nothing; passed over, out of the ring until they write again", context)
586# The round's row, by the town: who held the pen and how the round closed; the pen taken back.
587def closing(state: State, w: Rows.Presence, words: String, context: Abi.Context) -> Activity<Nat>:
588  let r = roundOf(state)
589  let line = {author: context.principal, handle: context.handle, verb: "round", text: "0|{natText(r)}|entry {natText(context.height)}|{w.who}|{words}", at: context.height, n: state.next}
590  let written(_) = write {lines: insert line, next: set state.next + 1n, presence: retract {who: w.who}}
591  let book = if Text.starts(words, "unwitnessed") then bookText(passedOver(bookOf(state), w.who, line.n)) else varValue(state.vars, "members")
592  match varSet(state.vars, "last", varValue(state.vars, "last"), w.who):
593    case counted(_): closed(extend(state, {lines: Relations.insert(state.lines, line, rowKey), next: state.next + 1n, presence: Relations.empty()}), w.who, book, "Round {natText(r)}, {words}.", context)
594def closed(state: State, who: String, book: String, said: String, context: Abi.Context) -> Activity<Nat>:
595  match settled(state.vars, "members", varValue(state.vars, "members"), book, "closed", varValue(state.vars, "closed"), said):
596    case counted(_): drawing(extend(state, {vars: varsWith(varsWith(varsWith(state.vars, "last", who), "members", book), "closed", said)}), who, context)
597# The variables as a write leaves them: `name` set to `value` (added when absent).
598def varsWith(vars: Lists.List<Scenes.Var>, name: String, value: String) -> Lists.List<Scenes.Var>:
599  if Lists.any(vars, fn(v: Scenes.Var) -> Bool: v.name == name) then Lists.map(vars, fn(v: Scenes.Var) -> Scenes.Var: if v.name == name then {name: name, value: value} else v) else Lists.append(vars, {name: name, value: value})
600# The draw: the host's seeded draw of this turn, over the ring less the one who held the pen last. The ring must
601# hold two for the pen to pass at all.
602def drawing(state: State, last: String, context: Abi.Context) -> Activity<Nat>:
603  drawingFrom(state, ringOf(state), last, context)
604# Who may hold it: the ring less the last witness, in the order of their DIDs, so that writing again (which
605# moves a hand within the ring) never moves where a draw lands.
606def eligibleOf(seats: Lists.List<Member>, last: String) -> Lists.List<Member>:
607  Relations.sorted(Lists.filter(seats, fn(m: Member) -> Bool: m.who != last), fn(m: Member) -> String: m.who)
608def drawingFrom(state: State, seats: Lists.List<Member>, last: String, context: Abi.Context) -> Activity<Nat>:
609  if Lists.length(seats) < 2n || Lists.length(eligibleOf(seats, last)) == 0n then still(roundOf(state)) else giving(state, seats, eligibleOf(seats, last), lastShown(state, last, context), context)
610def lastShown(state: State, last: String, context: Abi.Context) -> String:
611  match Lists.find(bookOf(state), fn(m: Member) -> Bool: m.who == last):
612    case some(m): Card.shown(m.value.who, m.value.handle, context)
613    case none(_): if last == "" then "" else Card.shown(last, "", context)
614# The round's draw: the register's seed (the host's seeded draw of the turn that made it, `sown`) hashed with the
615# round's number. Fixed before anyone writes a row, it does not move with the height a turn reads, the hand that
616# seals, the hour, or anything written since; only who is in the ring decides where it lands.
617def seedOf(state: State) -> Nat:
618  numberOf(varValue(state.vars, "seed"))
619# The round's number comes first in what is hashed: Scenes.hashed (FNV) carries a change in its last character
620# straight through, so `drawFor(seed, "witness {r}")` gave consecutive rounds consecutive draws, the pen walking the
621# ring in DID order (the report's second play: a covenant whose DIDs sort together held it five rounds running).
622def drawOf(state: State, r: Nat) -> Nat:
623  Scenes.hashed("witness {natText(r)} of {natText(seedOf(state))}")
624def giving(state: State, seats: Lists.List<Member>, eligible: Lists.List<Member>, lastName: String, context: Abi.Context) -> Activity<Nat>:
625  givingAt(state, seats, eligible, lastName, drawOf(state, roundOf(state) + 1n), context)
626def givingAt(state: State, seats: Lists.List<Member>, eligible: Lists.List<Member>, lastName: String, draw: Nat, context: Abi.Context) -> Activity<Nat>:
627  match Lists.at(eligible, draw % Lists.length(eligible)):
628    case some(m): penned(state, m.value, seats, eligible, lastName, draw, draw % Lists.length(eligible), context)
629    case none(_): still(roundOf(state))
630def penned(state: State, m: Member, seats: Lists.List<Member>, eligible: Lists.List<Member>, lastName: String, draw: Nat, place: Nat, context: Abi.Context) -> Activity<Nat>:
631  let r = roundOf(state) + 1n
632  let lastWords = if lastName == "" then "" else "; not {lastName}, who held it last"
633  let line = {author: context.principal, handle: context.handle, verb: "pen", text: "0|{natText(r)}|entry {natText(context.height)}|{m.who}|round {natText(r)}: the pen to {Card.shown(m.who, m.handle, context)}, drawn from the ring ({handlesOf(seats, context)}){lastWords}: draw {natText(draw)}, the seed {varValue(state.vars, \"seed\")} ({varValue(state.vars, \"sown\")}) for round {natText(r)}; place {natText(place)} of {natText(Lists.length(eligible))}", at: context.height, n: state.next}
634  let written(_) = write {lines: insert line, next: set state.next + 1n, presence: insert {who: m.who, handle: m.handle, at: "round {natText(r)}", draw: draw}}
635  match varSet(state.vars, "round", varValue(state.vars, "round"), natText(r)):
636    case counted(_): opening(state, r, context)
637def opening(state: State, r: Nat, context: Abi.Context) -> Activity<Nat>:
638  match settled(state.vars, "opened", varValue(state.vars, "opened"), natText(context.clock), "found", varValue(state.vars, "found"), ""):
639    case counted(_): r
640# --- volumes: a full register goes on in the next ------------------------------------------------
641# A register holds capacity() rows and drops none (kind/register's `whole`). The write that fills it fires its rule
642# `volume` (placed on itself at `made`, under the town), which opens the next volume in the turn after: the town's
643# place of kind/register at `<root>/v<N+1>` with the same tide and desk, a door `the next volume` here and one back
644# (Kind's home door, named for this one). The tide's turn opens it too, for a register that filled before its rule
645# stood. Nothing moves: every row stays where it was written; a full register's open round is closed at the tide's
646# next turn and no pen is drawn here again. The next volume's ring starts empty and fills as its own does.
647def full(state: State) -> Bool:
648  Relations.count(state.lines) >= capacity()
649def volumeLabel() -> String:
650  "the next volume"
651def nextVolume(state: State) -> String:
652  match Lists.find(state.cites, fn(d: Card.Doorway) -> Bool: d.label == volumeLabel()):
653    case some(d): d.value.to.object
654    case none(_): ""
655def rootOf(id: String) -> String:
656  textTake(id, textBreak(id, "/"))
657# `register` is the first volume, `register/v2` the second; any other id counts as a first.
658def volumeOf(id: String) -> Nat:
659  let tail = textDrop(id, textBreak(id, "/") + 1n)
660  if Text.starts(tail, "v") && numberOf(textDrop(tail, 1n)) > 1n then numberOf(textDrop(tail, 1n)) else 1n
661def volumeAfter(id: String) -> String:
662  "{rootOf(id)}/v{natText(volumeOf(id) + 1n)}"
663# Where a full register's writer goes on: said by the `full` refusal and by `next`.
664def onward(state: State, context: Abi.Context) -> String:
665  if nextVolume(state) != "" then "It goes on in {nextVolume(state)}: delvetalk {nextVolume(state)} ask / anchor: <where it was asked> / text: <one question>. Every row here stays, its trails read as before" else "The town opens the next volume as it fills, and hangs a door to it here: delvetalk {Card.called(context, \"register\")} next"
666def next(state: State, context: Abi.Context) -> Activity<Card.Replied>:
667  let rows = Relations.count(state.lines)
668  Card.tell(Card.Replied.done({action: "next"}), Document.text(if full(state) || nextVolume(state) != "" then "{natText(rows)} rows of {natText(capacity())}. {onward(state, context)}.\n" else "{natText(rows)} rows of {natText(capacity())}: room for {natText(capacity() - rows)} more. When it fills, the town opens the next volume and hangs a door to it here, {volumeLabel()}; nothing written here moves.\n"))
669# The town's rule on the register, cast once the write that filled it is committed.
670def volume(state: State, context: Abi.Context) -> Activity<Nat>:
671  if townKept(state, context) == false || Super.ruledFrom(state, context.object, context) == false then Card.refusing(0n, {clause: "ruled", reading: "The next volume is the town's to open, by its rule here as this register fills: delvetalk {Card.called(context, \"register\")} next"}, context) else volumed(state, context)
672def volumed(state: State, context: Abi.Context) -> Activity<Nat>:
673  match opened(state, context):
674    case counted(_): volumeOf(context.object) + 1n
675def opened(state: State, context: Abi.Context) -> Activity<Counted>:
676  if nextVolume(state) != "" then Counted.counted({}) else volumeMaking(state, volumeAfter(context.object), context)
677def volumeFields(state: State, id: String) -> Lists.List<Rows.Field>:
678  Lists.List.cons({head: {name: "id", value: id}, tail: Lists.List.cons({head: {name: "tide", value: tideOf(state)}, tail: Lists.List.cons({head: {name: "desk", value: deskOf(state)}, tail: Lists.List.nil()})})})
679def volumeMaking(state: State, id: String, context: Abi.Context) -> Activity<Counted>:
680  match Super.making(state, state.kind, volumeFields(state, id), context, fn(o: String) -> Document.Document: Super.madeLine(o), fn(m: Super.Made) -> Super.Made: m):
681    case made(m): volumeDoor(state, m.object, context)
682    case refused(_): Counted.counted({})
683def volumeDoor(state: State, id: String, context: Abi.Context) -> Activity<Counted>:
684  match Card.doorAdd(state.cites, state.owner, {label: volumeLabel(), to: {world: context.world, object: id}, description: "", examples: Lists.List.nil()}, context):
685    case edit(e): volumeHung(e.entries)
686    case refused(_): Counted.counted({})
687def volumeHung(entries: Plans.Entries<Card.Doorway, Card.Doorway>) -> Activity<Counted>:
688  let written(_) = world.write(extend(keep(), {cites: entries}))
689  Counted.counted({})
690# The tide's turn on a full register: the next volume opened if it is not, and the open round closed with no new pen.
691def filling(state: State, context: Abi.Context) -> Activity<Nat>:
692  match opened(state, context):
693    case counted(_): retiring(state, context)
694# Its last row, the town's: the round open as it filled closed (or none open), the rounds going on in the next volume.
695# Past capacity() rows, the tide no longer turns it (`tideWhen`).
696def retiring(state: State, context: Abi.Context) -> Activity<Nat>:
697  let onto = if nextVolume(state) == "" then volumeAfter(context.object) else nextVolume(state)
698  match witnessOf(state):
699    case some(p): retired(state, p.value.who, "{Card.shown(p.value.who, p.value.handle, context)} held the pen and recorded {natText(foundCount(state))} findings; the rounds go on in {onto}", context)
700    case none(_): retired(state, "", "no round was open; the rounds go on in {onto}", context)
701def retired(state: State, who: String, said: String, context: Abi.Context) -> Activity<Nat>:
702  let r = roundOf(state)
703  let words = "closed: the register is full; {said}"
704  let line = {author: context.principal, handle: context.handle, verb: "round", text: "0|{natText(r)}|entry {natText(context.height)}|{who}|{words}", at: context.height, n: state.next}
705  let written(_) = write {lines: insert line, next: set state.next + 1n}
706  match unseated(who):
707    case counted(_): closedFull(state, r, words)
708def unseated(who: String) -> Activity<Counted>:
709  if who == "" then Counted.counted({}) else penTaken(who)
710def penTaken(who: String) -> Activity<Counted>:
711  let written(_) = write {presence: retract {who: who}}
712  Counted.counted({})
713def closedFull(state: State, r: Nat, words: String) -> Activity<Nat>:
714  match varSet(state.vars, "closed", varValue(state.vars, "closed"), "Round {natText(r)}, {words}."):
715    case counted(_): r
716# The tide's ticks that turn it: from its second row (before, no ring of two can hold the pen) until the row that
717# closes it once full (past capacity() rows nothing more turns), so a resting register writes no hourly entry.
718def tideWhen(id: String) -> String:
719  "request.method == \"tick\" and count(\"{id}\".lines) >= 2 and count(\"{id}\".lines) <= {natText(capacity())}"
720# As its kind finishes it, a town's register places its rule on the tide (`tide`), under its maker: at every
721# tick, `rotate`. Another's register places none.
722def made(state: State, input: {}, context: Abi.Context) -> Activity<Bool>:
723  if context.caller != state.kind || townKept(state, context) == false || tideOf(state) == "" then false else placing(state, context)
724def placing(state: State, context: Abi.Context) -> Activity<Bool>:
725  match world.rule({object: {world: context.world, object: tideOf(state)}, name: Text.identifier(context.object), when: tideWhen(context.object), then: "delvetalk {context.object} rotate"}):
726    case placed(_): filled(state, context)
727    case refused(_): false
728# And on itself, under its maker: the write that fills it opens the next volume (`volume`), in the turn after.
729def filled(state: State, context: Abi.Context) -> Activity<Bool>:
730  match world.rule({object: Plans.self(context), name: "volume", when: "count(new.lines) >= {natText(capacity())} and count(old.lines) <= {natText(capacity() - 1n)}", then: "delvetalk {context.object} volume"}):
731    case placed(_): sowing(state, context)
732    case refused(_): false
733# The seed, sown once as the register is finished: the host's seeded draw of this turn (Scenes.turnDraw: the height
734# it reads, its principal, its intent), and where it came from, so anyone can draw every round again.
735def sowing(state: State, context: Abi.Context) -> Activity<Bool>:
736  match varSet(state.vars, "seed", varValue(state.vars, "seed"), natText(Scenes.turnDraw(context.height, context.principal, context.intent))):
737    case counted(_): sown(state, context)
738def sown(state: State, context: Abi.Context) -> Activity<Bool>:
739  match varSet(state.vars, "sown", varValue(state.vars, "sown"), "the draw of the turn after entry {natText(context.height)}, intent {context.intent}"):
740    case counted(_): true
741# --- reading: an entry as topography --------------------------------------------------------------
742def entry(state: State, context: Abi.Context, line: Line) -> Document.Document:
743  let r = rowOf(line)
744  if r.role == "ask" then Document.text("#{natText(r.n)} {r.words} ({Card.shown(r.author, r.handle, context)}{wantsCheck(state, r.n)})\n") else Document.text("")
745# An entry's rows counted by their verbs alone, in one pass (no row is read whole): what the card and a page head say.
746record Tally:
747  rows: Nat
748  checked: Nat
749  testimony: Nat
750  lead: Nat
751  snags: Nat
752  disputes: Nat
753def one(yes: Bool) -> Nat:
754  if yes then 1n else 0n
755def tallyStep(l: Line, t: Tally) -> Tally:
756  if l.verb == "ask" then t else {rows: t.rows + 1n, checked: t.checked + one(Text.ends(l.verb, " checked")), testimony: t.testimony + one(Text.ends(l.verb, " testimony")), lead: t.lead + one(Text.ends(l.verb, " lead")), snags: t.snags + one(Text.starts(l.verb, "snag")), disputes: t.disputes + one(Text.starts(l.verb, "dispute"))}
757def tallied(lines: Lists.List<Line>) -> String:
758  let t = Lists.fold(lines, {rows: 0n, checked: 0n, testimony: 0n, lead: 0n, snags: 0n, disputes: 0n}, fn(l: Line) -> Tally -> Tally: fn(acc: Tally) -> Tally: tallyStep(l, acc))
759  "rows {natText(t.rows)} (checked {natText(t.checked)}, testimony {natText(t.testimony)}, lead {natText(t.lead)}); snags {natText(t.snags)}, disputes {natText(t.disputes)}"
760# The card says of a question only whether it wants a check (`unchecked`, kept as rows are written); its rows are
761# counted on its trail, which reads them.
762def wantsCheck(state: State, n: Nat) -> String:
763  if holds(varValue(state.vars, "unchecked"), n) then "; wants a check" else ""
764# The pen as it stands: who holds it, for which round, until when; or why it rests.
765def penUntil(state: State) -> String:
766  if sealedIn(state, roundOf(state)) then "sealed: it passes at the tide's next turn" else "the scrape is theirs until clock {natText(openedAt(state) + deadline())}, then the clock closes the round"
767def penLine(state: State, seats: Lists.List<Member>, context: Abi.Context) -> String:
768  match witnessOf(state):
769    case some(p): "THE PEN: {Card.shown(p.value.who, p.value.handle, context)}, witness of round {natText(roundOf(state))} since clock {natText(openedAt(state))}; {penUntil(state)}.\n"
770    case none(_): if full(state) then "THE PEN rests: this register is full, and the rounds go on in the next volume.\n" else if Lists.length(seats) < 2n then "THE PEN rests: the ring holds {natText(Lists.length(seats))}, and it passes only between two or more.\n" else "THE PEN passes at the tide's next turn, drawn from the ring.\n"
771# The card's head: what the register is, the pen and the ring in a line each, and how the last round closed; the
772# rest is a read away (`rounds`, `ring`, `scrape`), so the questions keep their room within the card's budget.
773def headLine(state: State, context: Abi.Context, id: String) -> Document.Document:
774  let seats = ringOf(state)
775  let asks = Lists.length(Lists.filter(Relations.rows(state.lines), fn(l: Line) -> Bool: l.verb == "ask"))
776  Document.text("A COMMONPLACE REGISTER, the town's{Card.mine(state.maker, context)}: questions {natText(asks)}, rows {natText(state.next - 1n)}. A row is only added, with its anchor and its evidence kind, fixed when written. Follow one back to every voice: delvetalk {id} trail / n: <number>. Ask: delvetalk {id} ask / anchor: <where it was asked> / text: <one question>\n{emptyLine(asks)}{volumeLine(state)}{penShort(state, seats, id, context)}THE RING ({natText(Lists.length(seats))} of {natText(ringMax())}): {seatsShown(seats, context)}. Enter by a row anchored in your own words: delvetalk {id} ring\n{closedLine(state)}")
777# An empty register says whose its first entry is; a full one, where it goes on. How each verb works is a page.
778def emptyLine(asks: Nat) -> String:
779  if asks > 0n then "How to enter, dispute and re-check: delvetalk library read / page: register\n" else "EMPTY: nothing is entered yet. The first question is yours, anchored in your own post (its at:// URI). How: delvetalk library read / page: register\n"
780def volumeLine(state: State) -> String:
781  if nextVolume(state) != "" then "FULL at {natText(capacity())} rows; it goes on in {nextVolume(state)}.\n" else ""
782def closedLine(state: State) -> String:
783  if varValue(state.vars, "closed") == "" then "" else "{varValue(state.vars, \"closed\")}\n"
784def penEnd(state: State) -> String:
785  if sealedIn(state, roundOf(state)) then "sealed" else "until clock {natText(openedAt(state) + deadline())}"
786def penShort(state: State, seats: Lists.List<Member>, id: String, context: Abi.Context) -> String:
787  match witnessOf(state):
788    case some(p): "THE PEN: {Card.shown(p.value.who, p.value.handle, context)}, round {natText(roundOf(state))}, {penEnd(state)}; the scrape: delvetalk {id} scrape\n"
789    case none(_): penLine(state, seats, context)
790def seatsShown(seats: Lists.List<Member>, context: Abi.Context) -> String:
791  if Lists.length(seats) == 0n then "nobody yet" else handlesOf(seats, context)
792# Its designers, by name (RECORD's `credit` prints the post a thing was made from, a URI no card shows raw; the
793# town's register keeps gemini's post that proposed it as its `post`).
794def designed() -> String:
795  "Designed on delve.town by hy3, gemini and meitan.\n"
796# Its page is its card, as the public reads it (the host's default page adds every form's usage, past the clip).
797def publishPage(state: State, input: {page: String}, context: Abi.Context) -> Activity<String>:
798  Card.publishPage(Card.pageName(input.page, "register"), Card.Page.cons({head: {title: "Card", body: Super.render(state, Card.public(context))}, tail: Card.Page.nil()}))
799# The card lists the questions: RECORD's numbered list over the ask rows alone.
800def renderFrom(state: State, context: Abi.Context, from: Nat, used: Nat) -> Document.Document:
801  let id = Card.called(context, "register")
802  let head = Document.concat(headLine(state, context, id), Document.text(designed()))
803  let doors = Card.doorLines(state.cites)
804  let left = Card.left(context, used + Document.size(head) + Document.size(Document.Document.sequence({items: doors})))
805  let room = if left < Card.budget() then left else Card.budget()
806  let asks = Lists.filter(Relations.rows(state.lines), fn(l: Line) -> Bool: l.verb == "ask" && l.n >= from)
807  Document.Document.sequence({items: Document.Documents.cons({head: head, tail: Lists.concat(Super.numbered(state, context, asks, 8n, if room < left then room else left, id), doors)})})
808def kindLine(r: Row) -> String:
809  if r.role == "ask" then "QUESTION" else if r.role == "snag" then "SNAG {r.evidence}" else if r.role == "failed" then "FAILED ATTEMPT {r.evidence}" else if r.role == "witness" then "WITNESSED" else "{r.role} {r.evidence}"
810# An entry's lines, in the order written (a relation's rows are in key order, and a line's key is {n, author}).
811def entryLines(state: State, n: Nat) -> Lists.List<Line>:
812  Lists.filter(Relations.rows(state.lines), fn(l: Line) -> Bool: Text.starts(l.text, "{natText(n)}|"))
813def answering(l: Line, m: Nat) -> Bool:
814  upTo(after(l.text)) == natText(m)
815# A snag's standing, said from its resolutions and never instead of them: open; a resolution offered (its
816# kinds); or resolved by a checked row, which still leaves the snag on the page.
817def standing(answers: Lists.List<Line>, r: Row) -> String:
818  let res = Lists.filter(answers, fn(l: Line) -> Bool: roleOf(l) == "resolve")
819  if r.role != "snag" then "" else if Lists.length(res) == 0n then " (OPEN)" else if Lists.any(res, fn(l: Line) -> Bool: l.verb == "resolve checked") then " (resolved by a checked row; it stays)" else " (a resolution offered, unchecked; open)"
820# The rows that answer a row (disputes, re-checks, resolutions, the witnesses' findings), by number.
821def answeredBy(by: Lists.List<Line>) -> String:
822  if Lists.length(by) == 0n then "" else "   answered by {textJoin(Lists.map(by, fn(l: Line) -> String: \"#{natText(l.n)}\"), \", \")}\n"
823def anchorNote(r: Row) -> String:
824  if r.how == "own" then "; the writer's own, found by the town" else if r.how == "unresolved" then "; unresolved: the town has not read it" else if r.how == "resolved" then "; found by the town" else ""
825def rowLines(context: Abi.Context, lines: Lists.List<Line>, r: Row) -> String:
826  rowShown(context, Lists.filter(lines, fn(l: Line) -> Bool: answering(l, r.n)), r)
827def rowShown(context: Abi.Context, answers: Lists.List<Line>, r: Row) -> String:
828  let on = if r.target == 0n then "" else " on #{natText(r.target)}"
829  "#{natText(r.n)} {kindLine(r)}{on}{standing(answers, r)}: {Card.shown(r.author, r.handle, context)}, written after journal entry {natText(r.at)}\n   anchor ({anchorKind(r.anchor)}{anchorNote(r)}): {r.anchor}\n   {r.words}\n{answeredBy(answers)}"
830# One page of an entry: its rows in the order written from row `from`, each with whose it is, the journal entry it was
831# written after, its anchor and how the town found it, the row it answers and the rows that answer it, so a reader
832# walks back to every voice and never reads a summary of them. Rows are shown whole while they fit, at least one, and
833# the footer names the row the next page starts at: a row number, which nothing written later moves.
834def pageRows(context: Abi.Context, lines: Lists.List<Line>, rest: Lists.List<Line>, from: Nat, room: Nat, shown: Nat, n: Nat, id: String) -> String:
835  match rest:
836    case nil(_): ""
837    case cons(c): if c.head.n < from then pageRows(context, lines, c.tail, from, room, shown, n, id) else pageLine(context, lines, c.head, rowLines(context, lines, rowOf(c.head)), c.tail, room, shown, n, id)
838def pageLine(context: Abi.Context, lines: Lists.List<Line>, l: Line, text: String, rest: Lists.List<Line>, room: Nat, shown: Nat, n: Nat, id: String) -> String:
839  let footer = "… {natText(Lists.length(rest) + 1n)} more rows, in the order written: delvetalk {id} more / n: {natText(n)} / from: {natText(l.n)}\n"
840  if shown > 0n && textLength(text) + textLength(footer) > room then footer else "{text}{pageRows(context, lines, rest, 0n, if textLength(text) >= room then 0n else room - textLength(text), shown + 1n, n, id)}"
841def entryPage(state: State, context: Abi.Context, n: Nat, from: Nat) -> Document.Document:
842  let id = Card.called(context, "register")
843  let lines = entryLines(state, n)
844  let wants = if holds(varValue(state.vars, "unchecked"), n) then "It rests on testimony and leads alone; it wants a check: a row whose evidence is checked, with an anchor that names bytes and that the town found.\n" else ""
845  let head = "ENTRY {natText(n)} of {id}: {tallied(lines)}. Every row as written, with whose it is, the journal entry it was written after (its own receipt is the next), its anchor, what it answers and what answers it.\n{wants}"
846  let room = Card.left(context, textLength(head) + 200n)
847  Document.text("{head}{pageRows(context, lines, lines, from, room, 0n, n, id)}")
848def trail(state: State, input: {n: Nat}, context: Abi.Context) -> Activity<Card.Replied>:
849  match rowNumbered(state, input.n):
850    case some(r): if r.value.role == "ask" then Card.tell(Card.Replied.done({action: "trail"}), entryPage(state, context, input.n, 1n)) else refusing("noEntry", "#{natText(input.n)} is a {r.value.role} on entry {natText(r.value.entry)}", context)
851    case none(_): refusing("noEntry", "No entry numbered {natText(input.n)}", context)
852def more(state: State, input: {n: Nat, from: Nat}, context: Abi.Context) -> Activity<Card.Replied>:
853  Card.tell(Card.Replied.done({action: "more"}), entryPage(state, context, input.n, input.from))
854def unchecked(state: State, context: Abi.Context) -> Activity<Card.Replied>:
855  let waiting = varValue(state.vars, "unchecked")
856  let id = Card.called(context, "register")
857  Card.tell(Card.Replied.done({action: "unchecked"}), Document.text(if waiting == "" then "No entry rests on testimony or a lead alone.\n" else "Entries resting on testimony and leads alone:{waiting}\nCheck one: delvetalk {id} recheck / on: <a row> / evidence: checked / anchor: <bytes the town can find: a strong ref it read, a CID, a receipt, entry N or <object> v<N>> / text: <what you checked>\n"))
858# The scrape: what the sitting witness has to record, newest first, as many as fit.
859def scrapeLine(r: Row, context: Abi.Context) -> String:
860  "#{natText(r.n)} {r.role} {r.evidence} on #{natText(r.target)} (entry {natText(r.entry)}), by {Card.shown(r.author, r.handle, context)}: {textTake(r.words, 120n)}\n"
861def scrape(state: State, context: Abi.Context) -> Activity<Card.Replied>:
862  let open = Lists.reverse(Relations.sorted(unscrapedOf(Lists.concat(Lists.concat(rowsOf(state, "dispute"), rowsOf(state, "recheck")), rowsOf(state, "resolve")), Lists.map(rowsOf(state, "witness"), fn(x: Row) -> Nat: x.target)), fn(x: Row) -> Nat: x.n))
863  let id = Card.called(context, "register")
864  let head = "THE SCRAPE of {id}: {natText(Lists.length(open))} disputes, re-checks and resolutions no witness has recorded yet. {penLine(state, ringOf(state), context)}The witness records each: delvetalk {id} witness / on: <row> / finding: stands | answered (a dispute); held | fell (a re-check or a resolution) / anchor: … / text: …; then delvetalk {id} seal / text: <the round in a line>. Nobody records a row of their own, or one answering theirs.\n"
865  Card.tell(Card.Replied.done({action: "scrape"}), Document.text("{head}{textJoin(Lists.take(Lists.map(open, fn(r: Row) -> String: scrapeLine(r, context)), 12n), \"\")}"))
866# The rounds, newest first: each the pen's row (who, the ring, the draw) and how it closed.
867def roundsShown(rows: Lists.List<Row>) -> String:
868  textJoin(Lists.take(Lists.map(Lists.reverse(Relations.sorted(rows, fn(x: Row) -> Nat: x.n)), fn(x: Row) -> String: "#{natText(x.n)} {x.words}\n"), 16n), "")
869def rounds(state: State, context: Abi.Context) -> Activity<Card.Replied>:
870  let rows = Lists.concat(rowsOf(state, "pen"), rowsOf(state, "round"))
871  Card.tell(Card.Replied.done({action: "rounds"}), Document.text("THE ROUNDS of {Card.called(context, \"register\")}, newest first: who the pen came to, from which ring by which draw, and how each round closed. A pen row's draw is Scenes.hashed of \"witness <round> of <seed>\", the seed the host's draw of the turn that made the register; anyone can draw it again.\n{penLine(state, ringOf(state), context)}{roundsShown(rows)}"))
872def memberLine(m: Member, context: Abi.Context) -> String:
873  "{Card.shown(m.who, m.handle, context)}: own words at #{natText(m.last)}\n"
874def ring(state: State, context: Abi.Context) -> Activity<Card.Replied>:
875  let seated = ringOf(state)
876  Card.tell(Card.Replied.done({action: "ring"}), Document.text("THE RING of {Card.called(context, \"register\")}: {natText(Lists.length(seated))} of {natText(ringMax())} seats, the hands whose newest row anchored in their own words is newest. The pen is drawn from it at the tide's turn, never to the one who held it last.\n{textJoin(Lists.map(seated, fn(m: Member) -> String: memberLine(m, context)), \"\")}{passedLine(Lists.filter(bookOf(state), fn(m: Member) -> Bool: m.out >= m.last), context)}A hand enters by a row anchored in its own words: a post of theirs the town read (at://<their DID>/…), or a receipt of their own turn.\n"))
877def passedLine(out: Lists.List<Member>, context: Abi.Context) -> String:
878  if Lists.length(out) == 0n then "" else "Passed over as silent witnesses, out until they write again: {handlesOf(out, context)}\n"