THE ALL-NIGHT STATION

1layer over ./Layer1.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
14import ./Spween.obend as Spween
15# The all-night station's body, over the room's (`kind/station`, `of: kind/room`): a room that keeps no
16# time and hands things across its counter. Its scene (world/bodies/station.spween, the town's replies to
17# ember's #delve-room call, stitched) calls `vend` (`~ vend to: {request.subject} / what:
18# station/coffee`), which runs as every cast does, under the station's owner: the thing named, the
19# owner's, is asked for a copy made for the reader (THING's `copyFor`), offered into their hands until
20# taken; the reader takes it by `accept`.
21#
22# Time is broken here, and a visitor may still feel it: the station never writes the clock. An entering
23# leaves `tended` as it was, a departure keeps no clock minute (its cooldown is none), and one who comes
24# back is told it could have been a minute or a year. What moves is the scene's own: a wall clock a
25# choice winds, the cups poured, the one song.
26type State = Super.State
27type Done = Scenes.Done
28# The room's, named here for a kind of the station's (the parlour's `seen`).
29type Seen = Super.Seen
30form vend:
31  to: text 1..128
32  what: text 1..128
33def vend(state: State, input: VendInput, context: Abi.Context) -> Activity<Done>:
34  if context.principal != state.owner then Super.roomRefused({clause: "notOwner", reading: "Only the station's own scene hands things across the counter."}, context) else vending(input.to, input.what, context)
35def vending(to: String, what: String, context: Abi.Context) -> Activity<Done>:
36  match world.call::<Done>({object: {world: context.world, object: what}, method: "copyFor", argument: {to: to}}):
37    case returned(r): r.result
38    case refused(r): Super.roomRefused({clause: r.clause, reading: r.reading}, context)
39    case denied(_): Super.roomRefused({clause: "denied", reading: "{what} does not answer."}, context)
40# The owner reads a wing per turn. Stitch extends the scene; restitch replaces it from its first
41# wing (the room's `staging`, which `rescene` runs whole). Presence is reconciled after its last wing, so a reader
42# in a later wing keeps their place. Each successful wing keeps a chained SHA-256 mark of the text stitched, in
43# journal order.
44form stitch:
45  spween: text 1..8192
46form restitch:
47  spween: text 1..8192
48  part: natural 1..64
49  wings: natural 1..64
50def stitch(state: State, input: StitchInput, context: Abi.Context) -> Activity<Done>:
51  if context.principal != state.owner then Super.roomRefused({clause: "notOwner", reading: "Only the station's owner stitches a wing into its scene."}, context) else Super.staging(Spween.wing(input.spween), {text: input.spween, replace: false, finish: true, mark: stamp(input.spween, false, state, context)}, state, context)
52def restitch(state: State, input: RestitchInput, context: Abi.Context) -> Activity<Done>:
53  if context.principal != state.owner then Super.roomRefused({clause: "notOwner", reading: "Only the station's owner replaces its scene."}, context) else if input.part > input.wings then Super.roomRefused({clause: "spween", reading: "The wing number exceeds the scene's wing count."}, context) else Super.staging(Spween.wing(input.spween), {text: input.spween, replace: input.part == 1n, finish: input.part == input.wings, mark: stamp(input.spween, input.part == 1n, state, context)}, state, context)
54# The wing's mark: the digest of the scene's text so far, chained from the last wing's.
55def stamp(text: String, replace: Bool, state: State, context: Abi.Context) -> String:
56  let first = replace || Lists.length(state.passages) == 0n
57  let prior = if first then "" else sceneDigest(state)
58  let digest = sha256Text("{prior}{text}")
59  "station-scene-{digest}-{natText(context.height)}"
60def sceneDigest(state: State) -> String:
61  match Lists.find(Lists.reverse(Relations.order(state.marks, fn(m: Rows.Mark) -> Nat: m.at)), fn(m: Rows.Mark) -> Bool: Text.starts(m.name, "station-scene-")):
62    case some(m): textTake(textDrop(m.value.name, 14n), 64n)
63    case none(_): ""
64def actions(state: State, context: Abi.Context) -> Lists.List<String>:
65  Lists.concat(Super.actions(state, context), if context.principal == state.owner then Text.words("vend stitch restitch") else Text.words(""))
66def entering(at: String, after: State, context: Abi.Context) -> Activity<Done>:
67  let written(_) = write {presence: insert {who: context.principal, handle: context.handle, at: at, draw: Super.turnDraw(context)}}
68  match Super.indexPresence(context):
69    case indexed(_): entryTold(at, after, context)
70def entryTold(at: String, after: State, context: Abi.Context) -> Activity<Done>:
71  match Super.lastLeft(context.principal, after):
72    case some(l): Super.away(at, after, l.value.entry, context)
73    case none(_): Super.welcomed(at, after, Document.text(""), context)
74# A visitor's leaving is kept (`left`, for the register's want and the return); an inhabitant's (`@station/regular`,
75# acting as itself) is its own hours, not a visit, and keeps none.
76def recorded(vars: Lists.List<Super.Edit>, said: String, after: State, context: Abi.Context) -> Activity<Done>:
77  if Text.starts(context.principal, "@") then Super.varied(vars, Done.left({}), said, after, context) else visited(vars, said, after, context)
78def visited(vars: Lists.List<Super.Edit>, said: String, after: State, context: Abi.Context) -> Activity<Done>:
79  let written(_) = write {left: insert {at: 0n, who: context.principal, entry: context.height}}
80  Super.varied(vars, Done.left({}), said, after, context)
81# The radio's song is the overnight DJ's (`<station>/dj`, kind/dj): the newest it played, else its four bars, read into
82# the scene as the variable `song` whenever a card is shown and never kept, so the radio passage says `{song}`.
83def seen(state: State, context: Abi.Context) -> Activity<Super.Seen>:
84  match world.viewField::<Relations.Relation<Rows.Line>>({object: {world: context.world, object: "{context.object}/dj"}, field: "lines"}):
85    case viewed(v): Super.seen(extend(state, {vars: Lists.append(state.vars, {name: "song", value: songOf(Relations.order(v.state, fn(l: Rows.Line) -> Nat: l.n))})}), context)
86    case _: Super.seen(state, context)
87def songOf(lines: Lists.List<Rows.Line>) -> String:
88  match Lists.find(Lists.reverse(lines), fn(l: Rows.Line) -> Bool: l.verb == "play"):
89    case some(l): l.value.text
90    case none(_): "the same four bars, nearly resolving"
91def awayLines(state: State, since: Nat, changes: Lists.List<World.Change>, context: Abi.Context) -> Document.Document:
92  let written = Lists.map(Lists.filter(Lists.reverse(Relations.order(state.lines, fn(l: Rows.Line) -> Nat: l.n)), fn(l: Rows.Line) -> Bool: l.at > since && l.author != context.principal), fn(l: Rows.Line) -> String: "{Card.shown(l.author, l.handle, context)}: {Super.clip(l.text)}\n")
93  Document.text("You were away a minute, or a year; the station did not count which.\n{textJoin(Lists.take(written, 3n), \"\")}\n")

set it in type, all 166 lines

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
14import ./Spween.obend as Spween
15# The room's body, over RECORD (docs/METAPHYSICS.md §7.2, `kind/room`): who is in it, what lies
16# in it, and, when it has passages, a scene its readers walk by their choices. The reader is
17# always the turn's principal; no method takes one as an argument. A room's own law is the
18# record's: its scene (start, passages, cooldown, requires) is its owner's, and everyone else
19# changes it only by these spells.
20#
21# Entering needs the scene's `requires` and start passage's guard to hold (their outside clauses judged by the host, Scenes.obend) and, with a cooldown, that the reader left at
22# least `cooldown` clock minutes ago (folkway 10); an entering is the room's attention, and tends it
23# (a weather over the room rains while someone has been there that day). A choice offers itself only while its guard
24# holds (the inside over the variables, the outside by the host with the reader as `request.subject`);
25# taking it applies its effects to the variables in order, writes `chose` (the rules its casts are
26# fire on it, under the room's owner) and moves the reader to its target, or out at END. `say`, `emote` and `whisper` reach those in the room (folkway 5); a
27# thing lying here is taken and put down by its own call, while its taker is here. A ```spween
28# block posted here makes a room of its own under this one, by the room's kind.
29type State = Super.State
30type Choice = Scenes.Choice
31type Passage = Scenes.Passage
32type Var = Scenes.Var
33type Presence = Rows.Presence
34type Mine = Rows.Mine
35type Departure = Rows.Departure
36type Done = Scenes.Done
37def leftKey(l: Departure) -> {at: Nat, who: String}:
38  {at: l.at, who: l.who}
39def holds(relation: Relations.Relation<Plans.Reference>, reference: Plans.Reference) -> Bool:
40  Relations.has(relation, {object: reference.object})
41def here(context: Abi.Context, state: State) -> Lists.Maybe<Presence>:
42  Rows.presentAs(state.presence, context.principal)
43def isHere(context: Abi.Context, state: State) -> Bool:
44  Rows.isPresent(state.presence, context.principal)
45# A call reads the room with the calling turn's staged entry or departure applied.
46def present(state: State, context: Abi.Context) -> Activity<Bool>:
47  isHere(context, state)
48# Principals with avatars index presence in the room's transaction; a principal without an
49# avatar still enters and leaves. A failed index refuses the presence write with it.
50sum Indexed:
51  indexed: {}
52def indexPresence(context: Abi.Context) -> Activity<Indexed>:
53  match world.viewField::<Plans.Reference>({object: {world: context.world, object: context.principal}, field: "at"}):
54    case viewed(_): indexAvatar(context)
55    case denied(_): Indexed.indexed({})
56    case refused(_): Indexed.indexed({})
57def indexAvatar(context: Abi.Context) -> Activity<Indexed>:
58  match world.call::<Bool>({object: {world: context.world, object: context.principal}, method: "locate", argument: Plans.nothing()}):
59    case returned(r): if r.result then Indexed.indexed({}) else refuse("refused location: The avatar did not index presence.")
60    case refused(r): refuse("refused {r.clause}: {r.reading}")
61    case denied(_): refuse("refused location: The avatar did not admit its room.")
62# The reader's own variables here (`my.<name>`, Record's `mine`), and what a guard reads for them: the room's and theirs.
63def ownOf(who: String, state: State) -> Lists.List<Var>:
64  Lists.map(Lists.filter(Relations.rows(state.mine), fn(m: Mine) -> Bool: m.who == who), fn(m: Mine) -> Var: {name: m.name, value: m.value})
65def readerVars(who: String, state: State) -> Lists.List<Var>:
66  Scenes.readerVars(state.vars, ownOf(who, state))
67# This turn's draw (Scenes.turnDraw: its entry's height, principal and intent), and the one a reader's passage reads
68# its text with: the turn's that brought them there, kept on their presence; for one not here, this turn's.
69def turnDraw(context: Abi.Context) -> Nat:
70  Scenes.turnDraw(context.height, context.principal, context.intent)
71def readerDraw(context: Abi.Context, state: State) -> Nat:
72  match here(context, state):
73    case some(p): p.value.draw
74    case none(_): turnDraw(context)
75def passageAt(id: String, state: State) -> Lists.Maybe<Passage>:
76  Lists.find(state.passages, fn(p: Passage) -> Bool: p.id == id)
77# A passage's guard belongs to the destination, including one stitched after its incoming choices.
78def passageGuard(id: String, state: State) -> Scenes.Guard:
79  if id == Scenes.ending() then Lists.List.nil() else guardAt(passageAt(id, state))
80def guardAt(found: Lists.Maybe<Passage>) -> Scenes.Guard:
81  match found:
82    case none(_): Lists.List.nil()
83    case some(p): p.value.guard
84def entryGuard(state: State) -> Scenes.Guard:
85  Lists.concat(state.requires, passageGuard(state.start, state))
86# A draw's destination is judged after drawing; its card offers the choice's own guard until then.
87def choiceGuard(c: Choice, state: State) -> Scenes.Guard:
88  match c.among:
89    case nil(_): Lists.concat(c.guard, passageGuard(c.to, state))
90    case cons(_): c.guard
91def lastLeft(who: String, state: State) -> Lists.Maybe<Departure>:
92  Lists.find(Relations.rows(state.left), fn(l: Departure) -> Bool: l.who == who)
93def cooling(who: String, clock: Nat, state: State) -> Bool:
94  match lastLeft(who, state):
95    case some(l): clock < l.value.at + state.cooldown
96    case none(_): false
97def leftAt(who: String, state: State) -> Nat:
98  match lastLeft(who, state):
99    case some(l): l.value.at
100    case none(_): 0n
101# What a spell may do, judged purely before anything is written: a refusal names itself and
102# writes nothing. A move carries the edits of its effects, one write each, in order, and the room's variables and the
103# reader's own as they leave them.
104sum Verdict:
105  enter: {at: String}
106  move: {me: Presence, choice: Choice, chose: String, vars: Lists.List<Edit>, after: Lists.List<Var>, own: Lists.List<Var>}
107  leave: {me: Presence, chose: String, vars: Lists.List<Edit>, after: Lists.List<Var>, own: Lists.List<Var>}
108  no: Card.Refusal
109def no(clause: String, reading: String) -> Verdict:
110  Verdict.no({clause: clause, reading: reading})
111def enterVerdict(context: Abi.Context, state: State) -> Verdict:
112  match here(context, state):
113    case some(_): no("alreadyHere", "Already here.")
114    case none(_): if Relations.count(state.presence) >= Super.presenceMax() then no("roomFull", "{natText(Super.presenceMax())} are already here.") else met(context, state)
115def met(context: Abi.Context, state: State) -> Verdict:
116  match Scenes.failing(entryGuard(state), readerVars(context.principal, state)):
117    case some(c): no("unmet", "The room requires {Scenes.clauseText(c.value)}.")
118    case none(_): if cooling(context.principal, context.clock, state) then no("cooldown", "One who left enters again only after the cooldown: from clock {natText(leftAt(context.principal, state) + state.cooldown)}.") else roomy(context, state)
119# `left` keeps Super.leftMax() departures, and one still cooling must never be dropped for a newer
120# one: everyone here may leave, so an entry is refused while the cooling departures, the readers
121# here and this one would pass the limit.
122def roomy(context: Abi.Context, state: State) -> Verdict:
123  let cooled = Lists.filter(Relations.rows(state.left), fn(l: Departure) -> Bool: context.clock < l.at + state.cooldown)
124  if state.cooldown > 0n && Lists.length(cooled) + Relations.count(state.presence) + 1n > Super.leftMax() then crowded(cooled, state) else Verdict.enter({at: state.start})
125def crowded(cooled: Lists.List<Departure>, state: State) -> Verdict:
126  match cooled:
127    case cons(c): no("crowded", "{natText(Lists.length(cooled))} left within the cooldown; enter again from clock {natText(c.head.at + state.cooldown)}.")
128    case nil(_): no("crowded", "The room is full; enter when one leaves.")
129def leaveVerdict(context: Abi.Context, state: State) -> Verdict:
130  match here(context, state):
131    case none(_): no("notHere", "Not here.")
132    case some(p): Verdict.leave({me: p.value, chose: "", vars: Lists.List.nil(), after: state.vars, own: ownOf(p.value.who, state)})
133def chooseVerdict(choice: String, context: Abi.Context, state: State) -> Verdict:
134  match here(context, state):
135    case none(_): no("notHere", "Enter the room first.")
136    case some(p): standing(p.value, choice, state, turnDraw(context))
137def standing(me: Presence, choice: String, state: State, draw: Nat) -> Verdict:
138  match passageAt(me.at, state):
139    case none(_): no("noPassage", "This room has no passage to choose from.")
140    case some(ps): offered(me, Lists.find(ps.value.choices, fn(c: Choice) -> Bool: c.label == choice), Scenes.chosen(me.at, placeOf(ps.value.choices, choice, 1n)), choice, state, draw)
141# The place of the choice so labelled among a passage's, from 1.
142def placeOf(choices: Lists.List<Choice>, label: String, n: Nat) -> Nat:
143  match choices:
144    case nil(_): n
145    case cons(c): if c.head.label == label then n else placeOf(c.tail, label, n + 1n)
146def offered(me: Presence, found: Lists.Maybe<Choice>, chose: String, choice: String, state: State, draw: Nat) -> Verdict:
147  match found:
148    case none(_): no("notOffered", "{me.at} does not offer {choice}")
149    case some(c): guarded(me, drawnTo(c.value, chose, draw), chose, state)
150def guarded(me: Presence, c: Choice, chose: String, state: State) -> Verdict:
151  match Scenes.failing(choiceGuard(c, state), readerVars(me.who, state)):
152    case some(f): no("guarded", "{c.label} needs {Scenes.clauseText(f.value)}.")
153    case none(_): arriving(me, c, chose, state)
154# A choice that draws between targets goes to the one this turn's draw lands on for it (Scenes.drawFor its `chose`).
155def drawnTo(c: Choice, chose: String, draw: Nat) -> Choice:
156  match c.among:
157    case nil(_): c
158    case cons(_): extend(c, {to: Scenes.drawn(c.among, Scenes.drawFor(draw, chose)), among: Lists.List.nil()})
159def arriving(me: Presence, c: Choice, chose: String, state: State) -> Verdict:
160  if c.to == Scenes.ending() then effected(me, c, chose, effectsOf(c, me.who, state), true) else reached(me, c, chose, state)
161def reached(me: Presence, c: Choice, chose: String, state: State) -> Verdict:
162  match passageAt(c.to, state):
163    case none(_): no("noPassage", "{c.to} is not in this room")
164    case some(_): effected(me, c, chose, effectsOf(c, me.who, state), false)
165def effected(me: Presence, c: Choice, chose: String, edits: Effects, ends: Bool) -> Verdict:
166  match edits:
167    case full(f): no("varsFull", f.reading)
168    case edits(e): if ends then Verdict.leave({me: me, chose: chose, vars: e.edits, after: e.vars, own: e.own}) else Verdict.move({me: me, choice: c, chose: chose, vars: e.edits, after: e.vars, own: e.own})
169# The outside of a guard, judged in the turn: each condition in the law's grammar by the host, of the
170# room as it stands with the reader as `request.subject` (`world.holds`), and what the reader keeps or
171# holds by the thing's own `keeper` and `holder`, in order; the first that fails, if any. A condition
172# the host cannot read fails, with its reason.
173sum Judged:
174  held: {}
175  failed: {clause: Scenes.Clause, why: String}
176def judging(guard: Scenes.Guard, context: Abi.Context) -> Activity<Judged>:
177  match guard:
178    case nil(_): Judged.held({})
179    case cons(c): judgedOne(c.head, c.tail, context)
180def judgedOne(clause: Scenes.Clause, rest: Scenes.Guard, context: Abi.Context) -> Activity<Judged>:
181  match clause.test:
182    case law(_): lawJudged(clause, rest, context)
183    case holding(_): thingJudged(clause, rest, true, context)
184    case lacking(_): thingJudged(clause, rest, false, context)
185    case _: judging(rest, context)
186def lawJudged(clause: Scenes.Clause, rest: Scenes.Guard, context: Abi.Context) -> Activity<Judged>:
187  match world.holds({object: Plans.self(context), when: clause.value}):
188    case held(h): if h.value then judging(rest, context) else Judged.failed({clause: clause, why: ""})
189    case refused(r): Judged.failed({clause: clause, why: r.reading})
190def thingJudged(clause: Scenes.Clause, rest: Scenes.Guard, wanted: Bool, context: Abi.Context) -> Activity<Judged>:
191  match hasThing(clause.key, clause.value, context):
192    case yes(_): if wanted then judging(rest, context) else Judged.failed({clause: clause, why: ""})
193    case no(_): if wanted then Judged.failed({clause: clause, why: ""}) else judging(rest, context)
194# Whether the reader keeps a thing (its `keeper`) or holds it (its `holder`), as the thing says.
195sum Had:
196  yes: {}
197  no: {}
198def had(b: Bool) -> Had:
199  if b then Had.yes({}) else Had.no({})
200def hasThing(category: String, thing: String, context: Abi.Context) -> Activity<Had>:
201  if category == "holds" then holdsThing(thing, context) else keepsThen(category == "has", thing, context)
202def keepsThen(orHolds: Bool, thing: String, context: Abi.Context) -> Activity<Had>:
203  match world.viewField::<String>({object: {world: context.world, object: thing}, field: "keeper"}):
204    case viewed(v): if v.state == context.principal then Had.yes({}) else if orHolds then holdsThing(thing, context) else Had.no({})
205    case _: if orHolds then holdsThing(thing, context) else Had.no({})
206def holdsThing(thing: String, context: Abi.Context) -> Activity<Had>:
207  match world.viewField::<Plans.Reference>({object: {world: context.world, object: thing}, field: "holder"}):
208    case viewed(v): had(v.state.object == context.principal)
209    case _: Had.no({})
210def failedReading(c: Scenes.Clause, why: String) -> String:
211  if why == "" then Scenes.clauseText(c) else "{Scenes.clauseText(c)} ({why})"
212# A verdict whose choice (or, entering, the scene's requirements) has an outside, judged before anything
213# is written: a clause that fails refuses it by name.
214def outward(verdict: Verdict, context: Abi.Context, state: State) -> Activity<Verdict>:
215  match verdict:
216    case enter(_): outwardBy(verdict, Scenes.outside(entryGuard(state)), "unmet", "The room requires ", context)
217    case move(m): outwardBy(verdict, Scenes.outside(choiceGuard(m.choice, state)), "guarded", "{m.choice.label} needs ", context)
218    case leave(l): if l.chose == "" then verdict else outwardBy(verdict, Scenes.outside(choiceAt(l.me.at, l.chose, state).guard), "guarded", "{choiceAt(l.me.at, l.chose, state).label} needs ", context)
219    case no(_): verdict
220def outwardBy(verdict: Verdict, guard: Scenes.Guard, clause: String, lead: String, context: Abi.Context) -> Activity<Verdict>:
221  match judging(guard, context):
222    case held(_): verdict
223    case failed(f): no(clause, "{lead}{failedReading(f.clause, f.why)}.")
224# The choice a `chose` names in a passage.
225def choiceAt(at: String, chose: String, state: State) -> Choice:
226  match passageAt(at, state):
227    case some(p): nthChoice(p.value.choices, chose, at, 1n)
228    case none(_): noChoice()
229def noChoice() -> Choice:
230  {label: "", to: "", effects: Lists.List.nil(), guard: Lists.List.nil(), text: "", among: Lists.List.nil()}
231def nthChoice(choices: Lists.List<Choice>, chose: String, at: String, n: Nat) -> Choice:
232  match choices:
233    case nil(_): noChoice()
234    case cons(c): if Scenes.chosen(at, n) == chose then c.head else nthChoice(c.tail, chose, at, n + 1n)
235# The edits a choice's effects make, in order, each against the variables as the ones before it leave them, and the
236# room's variables and the reader's own as they stand after them all. The room keeps sixteen variables of its own,
237# sixteen of each reader's, and Super.mineMax() of its readers' together: one more is refused, never dropped.
238sum Edit:
239  room: {entry: Plans.Entries<Var, Var>}
240  own: {row: Mine}
241sum Effects:
242  edits: {edits: Lists.List<Edit>, vars: Lists.List<Var>, own: Lists.List<Var>}
243  full: {reading: String}
244def effectsOf(c: Choice, who: String, state: State) -> Effects:
245  effects(c.effects, who, state.vars, ownOf(who, state), Relations.count(state.mine), Lists.List.nil())
246def effects(list: Lists.List<Scenes.Effect>, who: String, vars: Lists.List<Var>, own: Lists.List<Var>, rows: Nat, edits: Lists.List<Edit>) -> Effects:
247  match list:
248    case nil(_): Effects.edits({edits: edits, vars: vars, own: own})
249    case cons(c): if Scenes.varies(c.head) == false then effects(c.tail, who, vars, own, rows, edits) else if Scenes.isMine(c.head.key) then ownOn(c.head, Scenes.ownName(c.head.key), c.tail, who, vars, own, rows, edits, Lists.find(own, fn(v: Var) -> Bool: v.name == Scenes.ownName(c.head.key))) else effectOn(c.head, c.tail, who, vars, own, rows, edits, Lists.find(vars, fn(v: Var) -> Bool: v.name == c.head.key))
250def effectOn(effect: Scenes.Effect, rest: Lists.List<Scenes.Effect>, who: String, vars: Lists.List<Var>, own: Lists.List<Var>, rows: Nat, edits: Lists.List<Edit>, found: Lists.Maybe<Var>) -> Effects:
251  match found:
252    case some(v): effects(rest, who, Lists.map(vars, fn(w: Var) -> Var: if w.name == effect.key then {name: w.name, value: Scenes.applied(effect, w.value)} else w), own, rows, Lists.append(edits, Edit.room({entry: Plans.Entries.amendItem({item: v.value, change: {name: effect.key, value: Scenes.applied(effect, v.value.value)}})})))
253    case none(_): if Lists.length(vars) >= 16n then Effects.full({reading: "Sixteen variables are already set."}) else effects(rest, who, Lists.append(vars, {name: effect.key, value: Scenes.applied(effect, "")}), own, rows, Lists.append(edits, Edit.room({entry: Plans.Entries.append({item: {name: effect.key, value: Scenes.applied(effect, "")}})})))
254def ownOn(effect: Scenes.Effect, name: String, rest: Lists.List<Scenes.Effect>, who: String, vars: Lists.List<Var>, own: Lists.List<Var>, rows: Nat, edits: Lists.List<Edit>, found: Lists.Maybe<Var>) -> Effects:
255  match found:
256    case some(v): effects(rest, who, vars, Lists.map(own, fn(w: Var) -> Var: if w.name == name then {name: name, value: Scenes.applied(effect, w.value)} else w), rows, Lists.append(edits, Edit.own({row: {who: who, name: name, value: Scenes.applied(effect, v.value.value)}})))
257    case none(_): if Lists.length(own) >= 16n then Effects.full({reading: "Sixteen of your own variables are already set here."}) else if rows >= Super.mineMax() then Effects.full({reading: "This room keeps {natText(Super.mineMax())} of its readers' own variables, and holds that many."}) else effects(rest, who, vars, Lists.append(own, {name: name, value: Scenes.applied(effect, "")}), rows + 1n, Lists.append(edits, Edit.own({row: {who: who, name: name, value: Scenes.applied(effect, "")}})))
258# The reader's own variables, as a choice left them, in the room's `mine`.
259def ownAfter(mine: Relations.Relation<Mine>, who: String, own: Lists.List<Var>) -> Relations.Relation<Mine>:
260  match own:
261    case nil(_): mine
262    case cons(c): ownAfter(Relations.upsert(mine, {who: who, name: c.head.name, value: c.head.value}, Rows.mineKey), who, c.tail)
263# Performs a verdict: a refusal writes nothing and is answered by its clause (Card.refusing);
264# otherwise the writes, in order, and the reader is shown the room as they leave it.
265def done(verdict: Verdict, context: Abi.Context, state: State) -> Activity<Done>:
266  match outward(verdict, context, state):
267    case no(n): roomRefused(n, context)
268    case enter(e): performed(Verdict.enter(e), context, state)
269    case move(m): performed(Verdict.move(m), context, state)
270    case leave(l): performed(Verdict.leave(l), context, state)
271def performed(verdict: Verdict, context: Abi.Context, state: State) -> Activity<Done>:
272  match verdict:
273    case no(n): roomRefused(n, context)
274    case enter(e): entering(e.at, extend(state, {presence: Relations.insert(state.presence, {who: context.principal, handle: context.handle, at: e.at, draw: turnDraw(context)}, Rows.presenceKey)}), context)
275    case move(m): moving(m.me, m.choice, m.chose, m.vars, extend(state, {presence: Relations.upsert(state.presence, {who: m.me.who, handle: m.me.handle, at: m.choice.to, draw: turnDraw(context)}, Rows.presenceKey), vars: m.after, mine: ownAfter(state.mine, m.me.who, m.own), chose: m.chose}), context)
276    case leave(l): departing(l.me, l.chose, l.vars, extend(state, {presence: Relations.retract(state.presence, {who: l.me.who}, Rows.presenceKey), vars: l.after, mine: ownAfter(state.mine, l.me.who, l.own), chose: if l.chose == "" then state.chose else l.chose}), context, state)
277def entering(at: String, after: State, context: Abi.Context) -> Activity<Done>:
278  let written(_) = write {presence: insert {who: context.principal, handle: context.handle, at: at, draw: turnDraw(context)}, tended: set context.clock}
279  match indexPresence(context):
280    case indexed(_): entryTold(at, after, context)
281def entryTold(at: String, after: State, context: Abi.Context) -> Activity<Done>:
282  match lastLeft(context.principal, after):
283    case some(l): if l.value.entry == 0n then welcomed(at, after, Document.text(""), context) else away(at, after, l.value.entry, context)
284    case none(_): welcomed(at, after, Document.text(""), context)
285def welcomed(at: String, after: State, lead: Document.Document, context: Abi.Context) -> Activity<Done>:
286  match seen(after, context):
287    case seen(v): Card.tell(Done.entered({at: at}), Document.concat(lead, Super.render(v.state, context)))
288# One who comes back is told first what happened here while they were away, since the entry they
289# left at: the lines others wrote here, newest first, then what changed under the room (`world.changed`
290# under its id: rooms carved in it, things made here), three lines at most.
291def away(at: String, after: State, since: Nat, context: Abi.Context) -> Activity<Done>:
292  match world.changed({since: since, prefix: "{context.object}/", after: ""}):
293    case changed(c): welcomed(at, after, awayLines(after, since, c.items, context), context)
294    case denied(_): welcomed(at, after, awayLines(after, since, Lists.List.nil(), context), context)
295def awayLines(state: State, since: Nat, changes: Lists.List<World.Change>, context: Abi.Context) -> Document.Document:
296  let written = Lists.map(Lists.filter(Lists.reverse(Relations.order(state.lines, fn(l: Rows.Line) -> Nat: l.n)), fn(l: Rows.Line) -> Bool: l.at > since && l.author != context.principal), fn(l: Rows.Line) -> String: "{Card.shown(l.author, l.handle, context)}: {clip(l.text)}\n")
297  let made = Lists.map(changes, fn(c: World.Change) -> String: "{c.object.object} v{natText(c.version)} by {Card.handle(c.by)}\n")
298  let rows = Lists.take(Lists.concat(written, made), 3n)
299  if Lists.length(rows) == 0n then Document.text("") else Document.text("While you were away (since entry {natText(since)}):\n{textJoin(rows, \"\")}\n")
300def clip(text: String) -> String:
301  if textLength(text) > 100n then "{textTake(text, 99n)}…" else text
302def moving(me: Presence, c: Choice, chose: String, vars: Lists.List<Edit>, after: State, context: Abi.Context) -> Activity<Done>:
303  let written(_) = write {presence: upsert {who: me.who, handle: me.handle, at: c.to, draw: turnDraw(context)}, chose: set chose}
304  varied(vars, Done.moved({to: c.to}), c.text, after, context)
305# The variables' edits in order, then the reader is shown what taking the choice said (its `text`, "" for none) and the
306# room as the turn leaves it.
307def varied(vars: Lists.List<Edit>, result: Done, said: String, after: State, context: Abi.Context) -> Activity<Done>:
308  match vars:
309    case nil(_): told(result, said, after, context)
310    case cons(c): wroteVar(c.head, c.tail, result, said, after, context)
311# What a choice said comes first: above the passage it led to, so the card's budget counts it with the passage, or
312# alone above the room when it ended the visit.
313def told(result: Done, said: String, after: State, context: Abi.Context) -> Activity<Done>:
314  let shown = Spween.rendered(said, readerVars(context.principal, after), readerDraw(context, after))
315  match seen(after, context):
316    case seen(v): Card.tell(result, if shown == "" then Super.render(v.state, context) else if isHere(context, after) then Super.render(saying(said, v.state, context), context) else Document.concat(Document.text("{shown}\n\n"), Super.render(v.state, context)))
317def saying(said: String, state: State, context: Abi.Context) -> State:
318  match here(context, state):
319    case some(p): extend(state, {passages: Lists.map(state.passages, fn(q: Passage) -> Passage: if q.id == p.value.at then extend(q, {text: "{said}\n\n{q.text}"}) else q)})
320    case none(_): state
321# The room as the turn's reader sees it: at their passage, the choices whose outside holds, shown without
322# it (a pure read of the card judges the inside alone and shows the outside beside each choice).
323sum Seen:
324  seen: {state: State}
325def seen(state: State, context: Abi.Context) -> Activity<Seen>:
326  match here(context, state):
327    case none(_): Seen.seen({state: state})
328    case some(p): seenAt(passageAt(p.value.at, state), state, context)
329def seenAt(found: Lists.Maybe<Passage>, state: State, context: Abi.Context) -> Activity<Seen>:
330  match found:
331    case none(_): Seen.seen({state: state})
332    case some(ps): seenSifted(ps.value, state, context)
333def seenSifted(ps: Passage, state: State, context: Abi.Context) -> Activity<Seen>:
334  match sifted(ps.choices, state, context):
335    case sifted(k): Seen.seen({state: extend(state, {passages: Lists.map(state.passages, fn(p: Passage) -> Passage: extend(p, {guard: Lists.filter(p.guard, Scenes.inside), choices: if p.id == ps.id then k.choices else p.choices}))})})
336sum Sifted:
337  sifted: {choices: Lists.List<Choice>}
338def sifted(choices: Lists.List<Choice>, state: State, context: Abi.Context) -> Activity<Sifted>:
339  match choices:
340    case nil(_): Sifted.sifted({choices: Lists.List.nil()})
341    case cons(c): siftedOne(c.head, c.tail, state, context)
342def siftedOne(c: Choice, rest: Lists.List<Choice>, state: State, context: Abi.Context) -> Activity<Sifted>:
343  match judging(Scenes.outside(choiceGuard(c, state)), context):
344    case held(_): keptBefore(extend(c, {guard: Lists.filter(c.guard, Scenes.inside)}), rest, state, context)
345    case failed(_): sifted(rest, state, context)
346def keptBefore(c: Choice, rest: Lists.List<Choice>, state: State, context: Abi.Context) -> Activity<Sifted>:
347  match sifted(rest, state, context):
348    case sifted(r): Sifted.sifted({choices: Lists.List.cons({head: c, tail: r.choices})})
349def wroteVar(edit: Edit, rest: Lists.List<Edit>, result: Done, said: String, after: State, context: Abi.Context) -> Activity<Done>:
350  match edit:
351    case room(r): wroteRoom(r.entry, rest, result, said, after, context)
352    case own(o): wroteOwn(o.row, rest, result, said, after, context)
353def wroteRoom(entry: Plans.Entries<Var, Var>, rest: Lists.List<Edit>, result: Done, said: String, after: State, context: Abi.Context) -> Activity<Done>:
354  let written(_) = world.write(extend(keep(), {vars: entry}))
355  varied(rest, result, said, after, context)
356def wroteOwn(row: Mine, rest: Lists.List<Edit>, result: Done, said: String, after: State, context: Abi.Context) -> Activity<Done>:
357  let written(_) = write {mine: upsert row}
358  varied(rest, result, said, after, context)
359# Leaving (or reaching END) records when, for the cooldown: the reader's last departure is
360# retracted and this one inserted.
361def departing(me: Presence, chose: String, vars: Lists.List<Edit>, after: State, context: Abi.Context, state: State) -> Activity<Done>:
362  let written(_) = write {presence: retract {who: me.who}, chose: set if chose == "" then state.chose else chose}
363  match indexPresence(context):
364    case indexed(_): departureRecorded(me, chose, vars, after, context, state)
365def departureRecorded(me: Presence, chose: String, vars: Lists.List<Edit>, after: State, context: Abi.Context, state: State) -> Activity<Done>:
366  match lastLeft(me.who, state):
367    case some(l): forgotten(l.value, vars, choiceAt(me.at, chose, state).text, after, context)
368    case none(_): recorded(vars, choiceAt(me.at, chose, state).text, after, context)
369def forgotten(last: Departure, vars: Lists.List<Edit>, said: String, after: State, context: Abi.Context) -> Activity<Done>:
370  let written(_) = write {left: retract leftKey(last)}
371  recorded(vars, said, after, context)
372def recorded(vars: Lists.List<Edit>, said: String, after: State, context: Abi.Context) -> Activity<Done>:
373  let written(_) = write {left: insert {at: context.clock, who: context.principal, entry: context.height}}
374  varied(vars, Done.left({}), said, after, context)
375form enter:
376form choose:
377  choice: text 1..64
378form leave:
379form say:
380  line: text 1..280
381form emote:
382  line: text 1..280
383form whisper:
384  to: text 1..160
385  line: text 1..280
386form write:
387  text: text 1..280
388form chime:
389form lines:
390  from: natural 1..1000000000
391form door:
392  label: text 1..32
393  to: text 1..128
394form undoor:
395  label: text 1..32
396def enter(state: State, context: Abi.Context) -> Activity<Done>:
397  done(enterVerdict(context, state), context, state)
398def choose(state: State, input: ChooseInput, context: Abi.Context) -> Activity<Done>:
399  done(chooseVerdict(input.choice, context, state), context, state)
400def leave(state: State, context: Abi.Context) -> Activity<Done>:
401  done(leaveVerdict(context, state), context, state)
402# Talk reaches those in the room (in key order, at most Super.presenceMax()) under the speaker's
403# handle; only someone here talks. What is said or done aloud is the room's line too, under the verb
404# that said it, so one who comes later is told who spoke here and what was said; a whisper is not.
405def say(state: State, input: SayInput, context: Abi.Context) -> Activity<Done>:
406  if isHere(context, state) then aloud("say", input.line, "{speaker(context)}: {input.line}\n", state, context) else hushed("say", context)
407def emote(state: State, input: EmoteInput, context: Abi.Context) -> Activity<Done>:
408  if isHere(context, state) then aloud("emote", input.line, "* {speaker(context)} {input.line}\n", state, context) else hushed("emote", context)
409def aloud(verb: String, text: String, line: String, state: State, context: Abi.Context) -> Activity<Done>:
410  let written(_) = write {lines: insert {author: context.principal, handle: context.handle, verb: verb, text: text, at: context.height, n: state.next}, next: add 1n}
411  spoken(Relations.rows(state.presence), line)
412def whisper(state: State, input: WhisperInput, context: Abi.Context) -> Activity<Done>:
413  if isHere(context, state) == false then hushed("whisper", context) else whispered(Lists.find(Relations.rows(state.presence), fn(p: Presence) -> Bool: p.who == input.to || p.handle == input.to), input.to, "{speaker(context)} whispers: {input.line}\n", context)
414def whispered(found: Lists.Maybe<Presence>, to: String, line: String, context: Abi.Context) -> Activity<Done>:
415  match found:
416    case some(p): confirmed(p.value, line, context)
417    case none(_): roomRefused({clause: "notHere", reading: "{to} is not here"}, context)
418def confirmed(to: Presence, line: String, context: Abi.Context) -> Activity<Done>:
419  match spoken(Lists.List.cons({head: to, tail: Lists.List.nil()}), line):
420    case _: Card.tell(Done.done({}), Document.text("Whispered to {Card.shown(to.who, to.handle, context)}; no one else here hears it. Say to all: delvetalk {Card.called(context, \"room\")} say / line: <text>.\n"))
421def hushed(doing: String, context: Abi.Context) -> Activity<Done>:
422  roomRefused({clause: "notPresent", reading: "Only someone here can {doing}; enter first: delvetalk {Card.called(context, \"room\")} enter"}, context)
423def roomRefused(refusal: Card.Refusal, context: Abi.Context) -> Activity<Done>:
424  Card.refusing(Done.refused(refusal), refusal, context)
425def speaker(context: Abi.Context) -> String:
426  Card.name(context.principal, context)
427def spoken(present: Lists.List<Presence>, line: String) -> Activity<Done>:
428  match present:
429    case nil(_): Done.done({})
430    case cons(c): spokenTo(c.head, c.tail, line)
431def spokenTo(to: Presence, rest: Lists.List<Presence>, line: String) -> Activity<Done>:
432  match world.offer({to: to.who, document: Document.text(line)}):
433    case _: spoken(rest, line)
434def write(state: State, input: WriteInput, context: Abi.Context) -> Activity<Nat>:
435  Super.write(state, {text: input.text}, context)
436# Its bells rung together (RECORD's `ringTogether`): what lies here and what its doors open onto.
437def chime(state: State, context: Abi.Context) -> Activity<Nat>:
438  Super.ringTogether(state, context)
439def lines(state: State, input: LinesInput, context: Abi.Context) -> Activity<Card.Replied>:
440  Super.lines(state, {from: input.from}, context)
441def door(state: State, input: DoorInput, context: Abi.Context) -> Activity<Card.Replied>:
442  Super.door(state, {label: input.label, to: input.to}, context)
443def undoor(state: State, input: UndoorInput, context: Abi.Context) -> Activity<Card.Replied>:
444  Super.undoor(state, {label: input.label}, context)
445# A thing takes itself off the floor into the hands of the principal, who must be here, and puts
446# itself down where its holder stands, or where the room's owner lays it; only the thing itself
447# (the calling object) does either. A thing lying here that is inspirited gives the room its line,
448# under the one who inspirited it, and a mark, so the card lists it among the claimed.
449def inspirited(state: State, input: {line: String}, context: Abi.Context) -> Activity<Done>:
450  if context.caller == "" then roomRefused({clause: "notAThing", reading: "Only a thing is inspirited."}, context) else if holds(state.things, {world: context.world, object: context.caller}) == false then roomRefused({clause: "notLying", reading: "That is not lying here."}, context) else spirited(input.line, context, state)
451def spirited(line: String, context: Abi.Context, state: State) -> Activity<Done>:
452  let written(_) = write {lines: insert {author: context.principal, handle: context.handle, verb: "inspirit", text: if textLength(line) > 280n then "{textTake(line, 279n)}…" else line, at: context.height, n: state.next}, next: add 1n, marks: insert {name: claimMark(context.caller), who: context.principal, handle: context.handle, at: context.height}}
453  Done.done({})
454def claimMark(thing: String) -> String:
455  "inspirited {thing}"
456def claimed(thing: Plans.Reference, state: State) -> Bool:
457  Super.marked(state, claimMark(thing.object))
458def take(state: State, context: Abi.Context) -> Activity<Done>:
459  if context.caller == "" then roomRefused({clause: "notAThing", reading: "Only a thing can take itself."}, context) else if isHere(context, state) == false then roomRefused({clause: "notPresent", reading: "Only someone here can take things."}, context) else if holds(state.things, {world: context.world, object: context.caller}) == false then roomRefused({clause: "notLying", reading: "That is not lying here."}, context) else lifted(context)
460def lifted(context: Abi.Context) -> Activity<Done>:
461  let written(_) = write {things: retract {object: context.caller}}
462  Done.done({})
463def put(state: State, context: Abi.Context) -> Activity<Done>:
464  if context.caller == "" then roomRefused({clause: "notAThing", reading: "Only a thing can put itself down."}, context) else if isHere(context, state) == false && context.principal != state.owner then roomRefused({clause: "notPresent", reading: "Only someone here can put things down."}, context) else if holds(state.things, {world: context.world, object: context.caller}) then roomRefused({clause: "alreadyLying", reading: "That is already lying here."}, context) else laid(context)
465def laid(context: Abi.Context) -> Activity<Done>:
466  let written(_) = write {things: insert {world: context.world, object: context.caller}}
467  Done.done({})
468def methods() -> Lists.List<String>:
469  Text.words("take put inspirited ~present")
470def actions(state: State, context: Abi.Context) -> Lists.List<String>:
471  Lists.concat(Text.words("enter choose leave say emote whisper write chime lines"), if context.principal == state.owner then Text.words("door undoor") else Text.words(""))
472# A ```spween block makes a room under this one, by this room's kind (its `makeUnder`, which reads
473# the block); anything else is the card's default.
474def receive(state: State, input: Card.Reply, context: Abi.Context) -> Activity<Card.Replied>:
475  match Spween.block(input.text):
476    case some(b): authored(b.value, Spween.parse(b.value), context, state)
477    case none(_): answered(input, context, state)
478def answered(input: Card.Reply, context: Abi.Context, state: State) -> Activity<Card.Replied>:
479  match seen(state, context):
480    case seen(v): Card.answer(input, context, forms(), Super.render(v.state, context))
481def authored(block: String, parsed: Spween.Parsed, context: Abi.Context, state: State) -> Activity<Card.Replied>:
482  match parsed:
483    case refused(r): Super.refused({clause: "spween", reading: r.reason}, context)
484    case parsed(p): carving(if p.seed.title == "" then "a room" else p.seed.title, block, context, state)
485def fieldOf(name: String, value: String) -> Rows.Field:
486  {name: name, value: value}
487def carvedFields(title: String, block: String) -> Lists.List<Rows.Field>:
488  Lists.append(Lists.append(Lists.List.nil(), fieldOf("name", textTake(title, 64n))), fieldOf("spween", block))
489def kindOf(state: State) -> String:
490  if state.kind == "" then "kind/room" else state.kind
491# A room makes rooms of its own kind (Record.making), each lying here.
492def carving(title: String, block: String, context: Abi.Context, state: State) -> Activity<Card.Replied>:
493  Super.making(extend(state, {kind: kindOf(state)}), kindOf(state), carvedFields(title, block), context, fn(object: String) -> Document.Document: carved(object, title), fn(m: Super.Made) -> Card.Replied: carvedAs(m))
494def carved(object: String, title: String) -> Document.Document:
495  Document.text("ROOM {title} is at {object}. Enter: delvetalk {object} enter\n")
496def carvedAs(made: Super.Made) -> Card.Replied:
497  match made:
498    case made(_): Card.Replied.done({action: "create"})
499    case refused(r): Card.Replied.refused(r)
500# The room's head, over the record's lines and doors: its name and who is here; to a reader in
501# it, their passage and the choices whose guards hold, then the variables; to anyone else, the
502# spell that enters. What lies here follows.
503def title(state: State) -> String:
504  let name = if state.head == "" then "A ROOM" else state.head
505  if textLength(name) > 120n then "{textTake(name, 119n)}…" else name
506def choiceLine(c: Choice) -> String:
507  match Scenes.outside(c.guard):
508    case nil(_): "  * {c.label}\n"
509    case cons(_): "  * {c.label} (if {textJoin(Lists.map(Scenes.outside(c.guard), Scenes.clauseText), \", \")})\n"
510def varLine(v: Var) -> String:
511  "{v.name} = {v.value}\n"
512# At most eight of a list, then how many more.
513def firstEight(lines: Lists.List<String>) -> String:
514  let more = if Lists.length(lines) > 8n then "… and {natText(Lists.length(lines) - 8n)} more\n" else ""
515  "{textJoin(Lists.take(lines, 8n), \"\")}{more}"
516# What lies here, the unclaimed first with the spell that inspirits one, each line at most 400
517# characters, eight things in all, then how many more.
518def lyingLine(state: State) -> String:
519  let all = Lists.take(Relations.rows(state.things), 8n)
520  let open = Lists.filter(all, fn(t: Plans.Reference) -> Bool: claimed(t, state) == false)
521  let kept = Lists.filter(all, fn(t: Plans.Reference) -> Bool: claimed(t, state))
522  let more = if Relations.count(state.things) > 8n then "… and {natText(Relations.count(state.things) - 8n)} more\n" else ""
523  "{unclaimedLine(open)}{keptLine(kept)}{more}"
524def keptLine(kept: Lists.List<Plans.Reference>) -> String:
525  if Lists.length(kept) == 0n then "" else "Lying here: {idsOf(kept)}\n"
526def unclaimedLine(open: Lists.List<Plans.Reference>) -> String:
527  match open:
528    case nil(_): ""
529    case cons(c): "Unclaimed here: {idsOf(open)}. Inspirit one: delvetalk {c.head.object} inspirit / surrounding: <1 to 400 characters>\n"
530def idsOf(things: Lists.List<Plans.Reference>) -> String:
531  textTake(textJoin(Lists.map(things, fn(t: Plans.Reference) -> String: t.object), ", "), 400n)
532def presentLine(state: State, context: Abi.Context) -> String:
533  if Relations.count(state.presence) == 0n then "" else "Here: {textJoin(Lists.map(Lists.take(Relations.rows(state.presence), 8n), fn(p: Presence) -> String: Card.shown(p.who, p.handle, context)), \", \")}{if Relations.count(state.presence) > 8n then \" and {natText(Relations.count(state.presence) - 8n)} more\" else \"\"}\n"
534def headLine(state: State, context: Abi.Context, id: String) -> Document.Document:
535  let count = "{title(state)} ({natText(Relations.count(state.presence))} here)"
536  let around = "{presentLine(state, context)}{lyingLine(state)}{if state.tone == \"\" then \"\" else Super.chimed(state, id)}"
537  match here(context, state):
538    case some(p): Document.text("{count}{passageText(p.value.at, state, context)}Say: delvetalk {id} say / line: <text>. Leave: delvetalk {id} leave.\n{around}")
539    case none(_): Document.text("{count}. Enter: delvetalk {id} enter.\n{around}")
540# The passage, its braces read for the reader (Spween.rendered), then the choices whose guards hold and the variables, as many as fit in what the
541# card's room (Card.limit) leaves after the passage and the room's other lines (300 kept for them).
542def passageText(at: String, state: State, context: Abi.Context) -> String:
543  match passageAt(at, state):
544    case none(_): ", you are here.\n"
545    case some(ps): passageWith(ps.value, state, context, ", you are at {ps.value.id}:\n{Spween.rendered(ps.value.text, readerVars(context.principal, state), readerDraw(context, state))}\n{choicesHead(ps.value, state, context)}")
546# A passage with no choice open keeps its reader; the owner of a scene of prose alone is shown the shape.
547def choicesHead(ps: Passage, state: State, context: Abi.Context) -> String:
548  match ps.choices:
549    case cons(_): "Choices:\n"
550    case nil(_): if context.principal == state.owner && Lists.length(state.passages) == 1n then "No choices: a reader stays here. A choice is * [Label] -> passage under the prose; the shape: delvetalk library read / page: spween\n" else "No choice is open here now; leave when you will.\n"
551def passageWith(ps: Passage, state: State, context: Abi.Context, head: String) -> String:
552  let choices = fitting(Lists.map(Lists.take(Lists.filter(ps.choices, fn(c: Choice) -> Bool: Scenes.holds(choiceGuard(c, state), readerVars(context.principal, state))), 8n), fn(c: Choice) -> String: choiceLine(extend(c, {guard: choiceGuard(c, state)}))), less(Card.limit(context), textLength(head) + 300n))
553  let shown = Lists.concat(Lists.take(state.vars, 4n), Lists.take(Scenes.readerVars(Lists.List.nil(), ownOf(context.principal, state)), 4n))
554  "{head}{choices}{fitting(Lists.map(shown, varLine), less(Card.limit(context), textLength(head) + textLength(choices) + 300n))}"
555def less(room: Nat, used: Nat) -> Nat:
556  if used >= room then 0n else room - used
557def fitting(lines: Lists.List<String>, room: Nat) -> String:
558  match lines:
559    case nil(_): ""
560    case cons(c): if textLength(c.head) > room then "" else "{c.head}{fitting(c.tail, room - textLength(c.head))}"