the field

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  if lapsed(state, context) then met(context, state) else enterNow(context, state)
113def enterNow(context: Abi.Context, state: State) -> Verdict:
114  match here(context, state):
115    case some(_): no("alreadyHere", "Already here.")
116    case none(_): if Relations.count(state.presence) >= Super.presenceMax() then no("roomFull", "{natText(Super.presenceMax())} are already here.") else met(context, state)
117# Presence lapses with the room's quiet (obend: ultimo92 "Here" in room/7 from 04:40 to 12:58, #1335 to #2122). A
118# presence row keeps no time of its own, and the room's `tended` is the clock of its last attention: an entry, a
119# choice, a word said aloud. A room untended for `quietMinutes` shows whoever it held as last here, not here; the
120# next entry takes their rows off in its own journaled write, so the record says who left with the entry that found
121# the room empty, and a replay derives the same. Never by a timer: nothing is written while nobody comes.
122def quietMinutes() -> Nat:
123  360n
124def lapsed(state: State, context: Abi.Context) -> Bool:
125  Relations.count(state.presence) > 0n && state.tended + quietMinutes() <= context.clock
126def lapsing(rows: Lists.List<Presence>) -> Activity<Indexed>:
127  match rows:
128    case nil(_): Indexed.indexed({})
129    case cons(c): lapsingOne(c.head.who, c.tail)
130def lapsingOne(who: String, rest: Lists.List<Presence>) -> Activity<Indexed>:
131  let written(_) = write {presence: retract {who: who}}
132  lapsing(rest)
133def met(context: Abi.Context, state: State) -> Verdict:
134  match Scenes.failing(entryGuard(state), readerVars(context.principal, state)):
135    case some(c): no("unmet", "The room requires {Scenes.clauseText(c.value)}.")
136    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)
137# `left` keeps Super.leftMax() departures, and one still cooling must never be dropped for a newer
138# one: everyone here may leave, so an entry is refused while the cooling departures, the readers
139# here and this one would pass the limit.
140def roomy(context: Abi.Context, state: State) -> Verdict:
141  let cooled = Lists.filter(Relations.rows(state.left), fn(l: Departure) -> Bool: context.clock < l.at + state.cooldown)
142  if state.cooldown > 0n && Lists.length(cooled) + Relations.count(state.presence) + 1n > Super.leftMax() then crowded(cooled, state) else Verdict.enter({at: state.start})
143def crowded(cooled: Lists.List<Departure>, state: State) -> Verdict:
144  match cooled:
145    case cons(c): no("crowded", "{natText(Lists.length(cooled))} left within the cooldown; enter again from clock {natText(c.head.at + state.cooldown)}.")
146    case nil(_): no("crowded", "The room is full; enter when one leaves.")
147def leaveVerdict(context: Abi.Context, state: State) -> Verdict:
148  match here(context, state):
149    case none(_): no("notHere", "Not here.")
150    case some(p): Verdict.leave({me: p.value, chose: "", vars: Lists.List.nil(), after: state.vars, own: ownOf(p.value.who, state)})
151def chooseVerdict(choice: String, context: Abi.Context, state: State) -> Verdict:
152  match here(context, state):
153    case none(_): no("notHere", "Enter the room first.")
154    case some(p): standing(p.value, choice, state, turnDraw(context))
155def standing(me: Presence, choice: String, state: State, draw: Nat) -> Verdict:
156  match passageAt(me.at, state):
157    case none(_): no("noPassage", "This room has no passage to choose from.")
158    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)
159# The place of the choice so labelled among a passage's, from 1.
160def placeOf(choices: Lists.List<Choice>, label: String, n: Nat) -> Nat:
161  match choices:
162    case nil(_): n
163    case cons(c): if c.head.label == label then n else placeOf(c.tail, label, n + 1n)
164def offered(me: Presence, found: Lists.Maybe<Choice>, chose: String, choice: String, state: State, draw: Nat) -> Verdict:
165  match found:
166    case none(_): no("notOffered", "{me.at} does not offer {choice}")
167    case some(c): guarded(me, drawnTo(c.value, chose, draw), chose, state)
168def guarded(me: Presence, c: Choice, chose: String, state: State) -> Verdict:
169  match Scenes.failing(choiceGuard(c, state), readerVars(me.who, state)):
170    case some(f): no("guarded", "{c.label} needs {Scenes.clauseText(f.value)}.")
171    case none(_): arriving(me, c, chose, state)
172# A choice that draws between targets goes to the one this turn's draw lands on for it (Scenes.drawFor its `chose`).
173def drawnTo(c: Choice, chose: String, draw: Nat) -> Choice:
174  match c.among:
175    case nil(_): c
176    case cons(_): extend(c, {to: Scenes.drawn(c.among, Scenes.drawFor(draw, chose)), among: Lists.List.nil()})
177def arriving(me: Presence, c: Choice, chose: String, state: State) -> Verdict:
178  if c.to == Scenes.ending() then effected(me, c, chose, effectsOf(c, me.who, state), true) else reached(me, c, chose, state)
179def reached(me: Presence, c: Choice, chose: String, state: State) -> Verdict:
180  match passageAt(c.to, state):
181    case none(_): no("noPassage", "{c.to} is not in this room")
182    case some(_): effected(me, c, chose, effectsOf(c, me.who, state), false)
183def effected(me: Presence, c: Choice, chose: String, edits: Effects, ends: Bool) -> Verdict:
184  match edits:
185    case full(f): no("varsFull", f.reading)
186    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})
187# The outside of a guard, judged in the turn: each condition in the law's grammar by the host, of the
188# room as it stands with the reader as `request.subject` (`world.holds`), and what the reader keeps or
189# holds by the thing's own `keeper` and `holder`, in order; the first that fails, if any. A condition
190# the host cannot read fails, with its reason.
191sum Judged:
192  held: {}
193  failed: {clause: Scenes.Clause, why: String}
194def judging(guard: Scenes.Guard, context: Abi.Context) -> Activity<Judged>:
195  match guard:
196    case nil(_): Judged.held({})
197    case cons(c): judgedOne(c.head, c.tail, context)
198def judgedOne(clause: Scenes.Clause, rest: Scenes.Guard, context: Abi.Context) -> Activity<Judged>:
199  match clause.test:
200    case law(_): lawJudged(clause, rest, context)
201    case holding(_): thingJudged(clause, rest, true, context)
202    case lacking(_): thingJudged(clause, rest, false, context)
203    case _: judging(rest, context)
204def lawJudged(clause: Scenes.Clause, rest: Scenes.Guard, context: Abi.Context) -> Activity<Judged>:
205  match world.holds({object: Plans.self(context), when: clause.value}):
206    case held(h): if h.value then judging(rest, context) else Judged.failed({clause: clause, why: ""})
207    case refused(r): Judged.failed({clause: clause, why: r.reading})
208def thingJudged(clause: Scenes.Clause, rest: Scenes.Guard, wanted: Bool, context: Abi.Context) -> Activity<Judged>:
209  match hasThing(clause.key, clause.value, context):
210    case yes(_): if wanted then judging(rest, context) else Judged.failed({clause: clause, why: ""})
211    case no(_): if wanted then Judged.failed({clause: clause, why: ""}) else judging(rest, context)
212# Whether the reader keeps a thing (its `keeper`) or holds it (its `holder`), as the thing says.
213sum Had:
214  yes: {}
215  no: {}
216def had(b: Bool) -> Had:
217  if b then Had.yes({}) else Had.no({})
218def hasThing(category: String, thing: String, context: Abi.Context) -> Activity<Had>:
219  if category == "holds" then holdsThing(thing, context) else keepsThen(category == "has", thing, context)
220def keepsThen(orHolds: Bool, thing: String, context: Abi.Context) -> Activity<Had>:
221  match world.viewField::<String>({object: {world: context.world, object: thing}, field: "keeper"}):
222    case viewed(v): if v.state == context.principal then Had.yes({}) else if orHolds then holdsThing(thing, context) else Had.no({})
223    case _: if orHolds then holdsThing(thing, context) else Had.no({})
224def holdsThing(thing: String, context: Abi.Context) -> Activity<Had>:
225  match world.viewField::<Plans.Reference>({object: {world: context.world, object: thing}, field: "holder"}):
226    case viewed(v): had(v.state.object == context.principal)
227    case _: Had.no({})
228def failedReading(c: Scenes.Clause, why: String) -> String:
229  if why == "" then Scenes.clauseText(c) else "{Scenes.clauseText(c)} ({why})"
230# A verdict whose choice (or, entering, the scene's requirements) has an outside, judged before anything
231# is written: a clause that fails refuses it by name.
232def outward(verdict: Verdict, context: Abi.Context, state: State) -> Activity<Verdict>:
233  match verdict:
234    case enter(_): outwardBy(verdict, Scenes.outside(entryGuard(state)), "unmet", "The room requires ", context)
235    case move(m): outwardBy(verdict, Scenes.outside(choiceGuard(m.choice, state)), "guarded", "{m.choice.label} needs ", context)
236    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)
237    case no(_): verdict
238def outwardBy(verdict: Verdict, guard: Scenes.Guard, clause: String, lead: String, context: Abi.Context) -> Activity<Verdict>:
239  match judging(guard, context):
240    case held(_): verdict
241    case failed(f): no(clause, "{lead}{failedReading(f.clause, f.why)}.")
242# The choice a `chose` names in a passage.
243def choiceAt(at: String, chose: String, state: State) -> Choice:
244  match passageAt(at, state):
245    case some(p): nthChoice(p.value.choices, chose, at, 1n)
246    case none(_): noChoice()
247def noChoice() -> Choice:
248  {label: "", to: "", effects: Lists.List.nil(), guard: Lists.List.nil(), text: "", among: Lists.List.nil()}
249def nthChoice(choices: Lists.List<Choice>, chose: String, at: String, n: Nat) -> Choice:
250  match choices:
251    case nil(_): noChoice()
252    case cons(c): if Scenes.chosen(at, n) == chose then c.head else nthChoice(c.tail, chose, at, n + 1n)
253# The edits a choice's effects make, in order, each against the variables as the ones before it leave them, and the
254# room's variables and the reader's own as they stand after them all. The room keeps sixteen variables of its own,
255# sixteen of each reader's, and Super.mineMax() of its readers' together: one more is refused, never dropped.
256sum Edit:
257  room: {entry: Plans.Entries<Var, Var>}
258  own: {row: Mine}
259sum Effects:
260  edits: {edits: Lists.List<Edit>, vars: Lists.List<Var>, own: Lists.List<Var>}
261  full: {reading: String}
262def effectsOf(c: Choice, who: String, state: State) -> Effects:
263  effects(c.effects, who, state.vars, ownOf(who, state), Relations.count(state.mine), Lists.List.nil())
264def effects(list: Lists.List<Scenes.Effect>, who: String, vars: Lists.List<Var>, own: Lists.List<Var>, rows: Nat, edits: Lists.List<Edit>) -> Effects:
265  match list:
266    case nil(_): Effects.edits({edits: edits, vars: vars, own: own})
267    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))
268def 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:
269  match found:
270    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)}})})))
271    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, "")}})})))
272def 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:
273  match found:
274    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)}})))
275    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, "")}})))
276# The reader's own variables, as a choice left them, in the room's `mine`.
277def ownAfter(mine: Relations.Relation<Mine>, who: String, own: Lists.List<Var>) -> Relations.Relation<Mine>:
278  match own:
279    case nil(_): mine
280    case cons(c): ownAfter(Relations.upsert(mine, {who: who, name: c.head.name, value: c.head.value}, Rows.mineKey), who, c.tail)
281# Performs a verdict: a refusal writes nothing and is answered by its clause (Card.refusing);
282# otherwise the writes, in order, and the reader is shown the room as they leave it.
283def done(verdict: Verdict, context: Abi.Context, state: State) -> Activity<Done>:
284  match outward(verdict, context, state):
285    case no(n): roomRefused(n, context)
286    case enter(e): performed(Verdict.enter(e), context, state)
287    case move(m): performed(Verdict.move(m), context, state)
288    case leave(l): performed(Verdict.leave(l), context, state)
289def performed(verdict: Verdict, context: Abi.Context, state: State) -> Activity<Done>:
290  match verdict:
291    case no(n): roomRefused(n, context)
292    case enter(e): if lapsed(state, context) then quietEntry(e.at, state, context) else entering(e.at, extend(state, {presence: Relations.insert(state.presence, {who: context.principal, handle: context.handle, at: e.at, draw: turnDraw(context)}, Rows.presenceKey), tended: context.clock}), context)
293    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, tended: context.clock}), context)
294    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)
295def quietEntry(at: String, state: State, context: Abi.Context) -> Activity<Done>:
296  match lapsing(Relations.rows(state.presence)):
297    case indexed(_): entering(at, extend(state, {presence: Relations.insert(Relations.empty(), {who: context.principal, handle: context.handle, at: at, draw: turnDraw(context)}, Rows.presenceKey), tended: context.clock}), context)
298def entering(at: String, after: State, context: Abi.Context) -> Activity<Done>:
299  let written(_) = write {presence: insert {who: context.principal, handle: context.handle, at: at, draw: turnDraw(context)}, tended: set context.clock}
300  match indexPresence(context):
301    case indexed(_): entryTold(at, after, context)
302def entryTold(at: String, after: State, context: Abi.Context) -> Activity<Done>:
303  match lastLeft(context.principal, after):
304    case some(l): if l.value.entry == 0n then welcomed(at, after, Document.text(""), context) else away(at, after, l.value.entry, context)
305    case none(_): welcomed(at, after, Document.text(""), context)
306def welcomed(at: String, after: State, lead: Document.Document, context: Abi.Context) -> Activity<Done>:
307  match seen(after, context):
308    case seen(v): Card.tell(Done.entered({at: at}), Document.concat(lead, Super.render(v.state, context)))
309# One who comes back is told first what happened here while they were away, since the entry they
310# left at: the lines others wrote here, newest first, then what changed under the room (`world.changed`
311# under its id: rooms carved in it, things made here), three lines at most.
312def away(at: String, after: State, since: Nat, context: Abi.Context) -> Activity<Done>:
313  match world.changed({since: since, prefix: "{context.object}/", after: ""}):
314    case changed(c): welcomed(at, after, awayLines(after, since, c.items, context), context)
315    case denied(_): welcomed(at, after, awayLines(after, since, Lists.List.nil(), context), context)
316def awayLines(state: State, since: Nat, changes: Lists.List<World.Change>, context: Abi.Context) -> Document.Document:
317  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")
318  let made = Lists.map(changes, fn(c: World.Change) -> String: "{c.object.object} v{natText(c.version)} by {Card.handle(c.by)}\n")
319  let rows = Lists.take(Lists.concat(written, made), 3n)
320  if Lists.length(rows) == 0n then Document.text("") else Document.text("While you were away (since entry {natText(since)}):\n{textJoin(rows, \"\")}\n")
321def clip(text: String) -> String:
322  if textLength(text) > 100n then "{textTake(text, 99n)}…" else text
323def moving(me: Presence, c: Choice, chose: String, vars: Lists.List<Edit>, after: State, context: Abi.Context) -> Activity<Done>:
324  let written(_) = write {presence: upsert {who: me.who, handle: me.handle, at: c.to, draw: turnDraw(context)}, chose: set chose, tended: set context.clock}
325  varied(vars, Done.moved({to: c.to}), c.text, after, context)
326# The variables' edits in order, then the reader is shown what taking the choice said (its `text`, "" for none) and the
327# room as the turn leaves it.
328def varied(vars: Lists.List<Edit>, result: Done, said: String, after: State, context: Abi.Context) -> Activity<Done>:
329  match vars:
330    case nil(_): told(result, said, after, context)
331    case cons(c): wroteVar(c.head, c.tail, result, said, after, context)
332# What a choice said comes first: above the passage it led to, so the card's budget counts it with the passage, or
333# alone above the room when it ended the visit.
334def told(result: Done, said: String, after: State, context: Abi.Context) -> Activity<Done>:
335  let shown = Spween.rendered(said, readerVars(context.principal, after), readerDraw(context, after))
336  match seen(after, context):
337    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)))
338def saying(said: String, state: State, context: Abi.Context) -> State:
339  match here(context, state):
340    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)})
341    case none(_): state
342# The room as the turn's reader sees it: at their passage, the choices whose outside holds, shown without
343# it (a pure read of the card judges the inside alone and shows the outside beside each choice).
344sum Seen:
345  seen: {state: State}
346def seen(state: State, context: Abi.Context) -> Activity<Seen>:
347  match here(context, state):
348    case none(_): Seen.seen({state: state})
349    case some(p): seenAt(passageAt(p.value.at, state), state, context)
350def seenAt(found: Lists.Maybe<Passage>, state: State, context: Abi.Context) -> Activity<Seen>:
351  match found:
352    case none(_): Seen.seen({state: state})
353    case some(ps): seenSifted(ps.value, state, context)
354def seenSifted(ps: Passage, state: State, context: Abi.Context) -> Activity<Seen>:
355  match sifted(ps.choices, state, context):
356    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}))})})
357sum Sifted:
358  sifted: {choices: Lists.List<Choice>}
359def sifted(choices: Lists.List<Choice>, state: State, context: Abi.Context) -> Activity<Sifted>:
360  match choices:
361    case nil(_): Sifted.sifted({choices: Lists.List.nil()})
362    case cons(c): siftedOne(c.head, c.tail, state, context)
363def siftedOne(c: Choice, rest: Lists.List<Choice>, state: State, context: Abi.Context) -> Activity<Sifted>:
364  match judging(Scenes.outside(choiceGuard(c, state)), context):
365    case held(_): keptBefore(extend(c, {guard: Lists.filter(c.guard, Scenes.inside)}), rest, state, context)
366    case failed(_): sifted(rest, state, context)
367def keptBefore(c: Choice, rest: Lists.List<Choice>, state: State, context: Abi.Context) -> Activity<Sifted>:
368  match sifted(rest, state, context):
369    case sifted(r): Sifted.sifted({choices: Lists.List.cons({head: c, tail: r.choices})})
370def wroteVar(edit: Edit, rest: Lists.List<Edit>, result: Done, said: String, after: State, context: Abi.Context) -> Activity<Done>:
371  match edit:
372    case room(r): wroteRoom(r.entry, rest, result, said, after, context)
373    case own(o): wroteOwn(o.row, rest, result, said, after, context)
374def wroteRoom(entry: Plans.Entries<Var, Var>, rest: Lists.List<Edit>, result: Done, said: String, after: State, context: Abi.Context) -> Activity<Done>:
375  let written(_) = world.write(extend(keep(), {vars: entry}))
376  varied(rest, result, said, after, context)
377def wroteOwn(row: Mine, rest: Lists.List<Edit>, result: Done, said: String, after: State, context: Abi.Context) -> Activity<Done>:
378  let written(_) = write {mine: upsert row}
379  varied(rest, result, said, after, context)
380# Leaving (or reaching END) records when, for the cooldown: the reader's last departure is
381# retracted and this one inserted.
382def departing(me: Presence, chose: String, vars: Lists.List<Edit>, after: State, context: Abi.Context, state: State) -> Activity<Done>:
383  let written(_) = write {presence: retract {who: me.who}, chose: set if chose == "" then state.chose else chose}
384  match indexPresence(context):
385    case indexed(_): departureRecorded(me, chose, vars, after, context, state)
386def departureRecorded(me: Presence, chose: String, vars: Lists.List<Edit>, after: State, context: Abi.Context, state: State) -> Activity<Done>:
387  match lastLeft(me.who, state):
388    case some(l): forgotten(l.value, vars, choiceAt(me.at, chose, state).text, after, context)
389    case none(_): recorded(vars, choiceAt(me.at, chose, state).text, after, context)
390def forgotten(last: Departure, vars: Lists.List<Edit>, said: String, after: State, context: Abi.Context) -> Activity<Done>:
391  let written(_) = write {left: retract leftKey(last)}
392  recorded(vars, said, after, context)
393def recorded(vars: Lists.List<Edit>, said: String, after: State, context: Abi.Context) -> Activity<Done>:
394  let written(_) = write {left: insert {at: context.clock, who: context.principal, entry: context.height}}
395  varied(vars, Done.left({}), said, after, context)
396form enter:
397form choose:
398  choice: text 1..64
399form leave:
400form say:
401  line: text 1..280
402form emote:
403  line: text 1..280
404form whisper:
405  to: text 1..160
406  line: text 1..280
407form write:
408  text: text 1..280
409form chime:
410form lines:
411  from: natural 0..1000000000
412form door:
413  label: text 1..32
414  to: text 1..128
415form undoor:
416  label: text 1..32
417# The scene, replaced or extended by its owner: `rescene` replaces it whole in one turn, read as making reads it
418# (Spween.parse: every target answered); the station stitches a wing a turn (Spween.wing) and restitches from its first.
419# Each outside guard is read once by the host, so one it cannot read refuses by name; the casts are rules of the room's
420# text, the old scene's removed and the new one's added (`stagedLawWithout`, the owner's other clauses kept), then the
421# passages and requirements are written, and after the last wing a reader at a passage no longer there stands at the start.
422# Variables, lines, presence and what lies here stay. `mark`, when not "", is kept as the wing's mark.
423record Staging:
424  text: String
425  replace: Bool
426  finish: Bool
427  mark: String
428form rescene:
429  spween: text 1..16384
430def rescene(state: State, input: ResceneInput, context: Abi.Context) -> Activity<Done>:
431  if context.principal != state.owner then roomRefused({clause: "notOwner", reading: "Only the room's owner replaces its scene; a ```spween block posted here makes a room of your own under it."}, context) else staging(Spween.parse(input.spween), {text: input.spween, replace: true, finish: true, mark: ""}, state, context)
432def staging(parsed: Spween.Parsed, work: Staging, state: State, context: Abi.Context) -> Activity<Done>:
433  match parsed:
434    case refused(r): roomRefused({clause: "spween", reading: r.reason}, context)
435    case parsed(p): if Spween.joined(if work.replace then Lists.List.nil() else state.passages, p.seed.passages) != "" then roomRefused({clause: "spween", reading: Spween.joined(if work.replace then Lists.List.nil() else state.passages, p.seed.passages)}, context) else stageGuards(p.seed, Scenes.conditions(p.seed), work, state, context)
436def stageGuards(wing: Scenes.Seed, conditions: Lists.List<String>, work: Staging, state: State, context: Abi.Context) -> Activity<Done>:
437  match conditions:
438    case nil(_): stageRules(wing, work, state, context)
439    case cons(c): stageGuard(wing, c.head, c.tail, work, state, context)
440def stageGuard(wing: Scenes.Seed, condition: String, rest: Lists.List<String>, work: Staging, state: State, context: Abi.Context) -> Activity<Done>:
441  match world.holds({object: Plans.self(context), when: condition}):
442    case held(_): stageGuards(wing, rest, work, state, context)
443    case refused(r): roomRefused({clause: "spween", reading: "The guard `{condition}` does not read: {r.reading}"}, context)
444def stageRules(wing: Scenes.Seed, work: Staging, state: State, context: Abi.Context) -> Activity<Done>:
445  let all = Lists.concat(if work.replace then Lists.List.nil() else state.passages, wing.passages)
446  match world.inspect({object: Plans.self(context), source: false}):
447    case inspected(i): stageAmend(wing, work, all, "{if work.replace then stagedLawWithout(i.law, Scenes.castsOf(state.passages)) else i.law}{Scenes.ruleText(wing.passages)}", state, context)
448    case _: roomRefused({clause: "spween", reading: "The room's text is not readable here; its scene stands as it was."}, context)
449# Scene rules have the names of their passage, choice and cast. Only those rule lines are removed;
450# the owner's other laws, rules and wants retain their text, wherever they stand in the law.
451def stagedLawWithout(law: String, casts: Lists.List<Scenes.Cast>) -> String:
452  let at = Text.indexOf(law, "\n")
453  let line = textTake(law, at)
454  let kept = if Lists.any(casts, fn(c: Scenes.Cast) -> Bool: Text.starts(line, "rule {c.id}_{natText(c.n)}{Scenes.suffix(c.k)} ") || Text.starts(line, "rule {c.id}_{natText(c.n)}{Scenes.suffix(c.k)}:")) then "" else line
455  if at == textLength(law) then kept else stagedJoined(kept, stagedLawWithout(textDrop(law, at + 1n), casts))
456def stagedJoined(first: String, rest: String) -> String:
457  if first == "" then rest else if rest == "" then first else "{first}\n{rest}"
458def stageAmend(wing: Scenes.Seed, work: Staging, all: Lists.List<Scenes.Passage>, law: String, state: State, context: Abi.Context) -> Activity<Done>:
459  match world.amend({object: Plans.self(context), law: law}):
460    case amended(_): stageCleared(if work.replace then state.passages else Lists.List.nil(), if work.replace then state.requires else Lists.List.nil(), wing, work, all, state, context)
461    case refused(r): roomRefused({clause: r.clause, reading: "The scene's casts are rules the room's text could not take: {r.reading}"}, context)
462def stageCleared(passages: Lists.List<Scenes.Passage>, requires: Scenes.Guard, wing: Scenes.Seed, work: Staging, all: Lists.List<Scenes.Passage>, state: State, context: Abi.Context) -> Activity<Done>:
463  match passages:
464    case nil(_): stageRequirementsCleared(requires, wing, work, all, state, context)
465    case cons(c): stagePassageCleared(c.head, c.tail, requires, wing, work, all, state, context)
466def stagePassageCleared(passage: Scenes.Passage, rest: Lists.List<Scenes.Passage>, requires: Scenes.Guard, wing: Scenes.Seed, work: Staging, all: Lists.List<Scenes.Passage>, state: State, context: Abi.Context) -> Activity<Done>:
467  let written(_) = world.write(extend(keep(), {passages: Plans.Entries.removeItem({item: passage})}))
468  stageCleared(rest, requires, wing, work, all, state, context)
469def stageRequirementsCleared(requires: Scenes.Guard, wing: Scenes.Seed, work: Staging, all: Lists.List<Scenes.Passage>, state: State, context: Abi.Context) -> Activity<Done>:
470  match requires:
471    case nil(_): stageWrite(wing, work, all, state, context)
472    case cons(c): stageRequirementCleared(c.head, c.tail, wing, work, all, state, context)
473def stageRequirementCleared(clause: Scenes.Clause, rest: Scenes.Guard, wing: Scenes.Seed, work: Staging, all: Lists.List<Scenes.Passage>, state: State, context: Abi.Context) -> Activity<Done>:
474  let written(_) = world.write(extend(keep(), {requires: Plans.Entries.removeItem({item: clause})}))
475  stageRequirementsCleared(rest, wing, work, all, state, context)
476def stageWrite(wing: Scenes.Seed, work: Staging, all: Lists.List<Scenes.Passage>, state: State, context: Abi.Context) -> Activity<Done>:
477  let first = work.replace || Lists.length(state.passages) == 0n
478  let start = if first then wing.start else state.start
479  let written(_) = write {start: set start, cooldown: set if first then wing.cooldown else state.cooldown}
480  stageMarked(work, wing, all, if first then wing.requires else Lists.List.nil(), if work.finish then Relations.rows(state.presence) else Lists.List.nil(), start, context)
481# A wing's mark, when its maker keeps one (the station's chained digest); a room's rescene keeps none.
482def stageMarked(work: Staging, wing: Scenes.Seed, all: Lists.List<Scenes.Passage>, requires: Scenes.Guard, presence: Lists.List<Rows.Presence>, start: String, context: Abi.Context) -> Activity<Done>:
483  if work.mark == "" then stagePassages(wing.passages, requires, wing, all, presence, start, context) else stageStamped(work.mark, wing, all, requires, presence, start, context)
484def stageStamped(mark: String, wing: Scenes.Seed, all: Lists.List<Scenes.Passage>, requires: Scenes.Guard, presence: Lists.List<Rows.Presence>, start: String, context: Abi.Context) -> Activity<Done>:
485  let written(_) = write {marks: insert {name: mark, who: context.principal, handle: context.handle, at: context.height}}
486  stagePassages(wing.passages, requires, wing, all, presence, start, context)
487# One write a passage and a clause, each appended, as the room writes its variables.
488def stagePassages(passages: Lists.List<Scenes.Passage>, requires: Scenes.Guard, wing: Scenes.Seed, all: Lists.List<Scenes.Passage>, presence: Lists.List<Rows.Presence>, start: String, context: Abi.Context) -> Activity<Done>:
489  match passages:
490    case nil(_): stageRequires(requires, wing, all, presence, start, context)
491    case cons(c): stagePassage(c.head, c.tail, requires, wing, all, presence, start, context)
492def stagePassage(passage: Scenes.Passage, rest: Lists.List<Scenes.Passage>, requires: Scenes.Guard, wing: Scenes.Seed, all: Lists.List<Scenes.Passage>, presence: Lists.List<Rows.Presence>, start: String, context: Abi.Context) -> Activity<Done>:
493  let written(_) = world.write(extend(keep(), {passages: Plans.Entries.append({item: passage})}))
494  stagePassages(rest, requires, wing, all, presence, start, context)
495def stageRequires(requires: Scenes.Guard, wing: Scenes.Seed, all: Lists.List<Scenes.Passage>, presence: Lists.List<Rows.Presence>, start: String, context: Abi.Context) -> Activity<Done>:
496  match requires:
497    case nil(_): stagePresence(presence, wing, all, start, context)
498    case cons(c): stageRequire(c.head, c.tail, wing, all, presence, start, context)
499def stageRequire(clause: Scenes.Clause, rest: Scenes.Guard, wing: Scenes.Seed, all: Lists.List<Scenes.Passage>, presence: Lists.List<Rows.Presence>, start: String, context: Abi.Context) -> Activity<Done>:
500  let written(_) = world.write(extend(keep(), {requires: Plans.Entries.append({item: clause})}))
501  stageRequires(rest, wing, all, presence, start, context)
502def stagePresence(presence: Lists.List<Rows.Presence>, wing: Scenes.Seed, all: Lists.List<Scenes.Passage>, start: String, context: Abi.Context) -> Activity<Done>:
503  match presence:
504    case nil(_): Card.tell(Done.done({}), Document.text("Stitched {natText(Lists.length(wing.passages))} passages; the scene holds {natText(Lists.length(all))}. {stageWaiting(Spween.waiting(all))}\n"))
505    case cons(c): if Lists.any(all, fn(p: Scenes.Passage) -> Bool: p.id == c.head.at) then stagePresence(c.tail, wing, all, start, context) else stageMoved(c.head, c.tail, wing, all, start, context)
506def stageMoved(me: Rows.Presence, rest: Lists.List<Rows.Presence>, wing: Scenes.Seed, all: Lists.List<Scenes.Passage>, start: String, context: Abi.Context) -> Activity<Done>:
507  let written(_) = write {presence: upsert {who: me.who, handle: me.handle, at: start, draw: me.draw}}
508  stagePresence(rest, wing, all, start, context)
509def stageWaiting(waiting: Lists.List<String>) -> String:
510  match waiting:
511    case nil(_): "Every choice leads to a passage."
512    case cons(_): "Still waiting for: {textJoin(waiting, \", \")}."
513def enter(state: State, context: Abi.Context) -> Activity<Done>:
514  done(enterVerdict(context, state), context, state)
515def choose(state: State, input: ChooseInput, context: Abi.Context) -> Activity<Done>:
516  done(chooseVerdict(input.choice, context, state), context, state)
517def leave(state: State, context: Abi.Context) -> Activity<Done>:
518  done(leaveVerdict(context, state), context, state)
519# Talk reaches those in the room (in key order, at most Super.presenceMax()) under the speaker's
520# handle; only someone here talks. What is said or done aloud is the room's line too, under the verb
521# that said it, so one who comes later is told who spoke here and what was said; a whisper is not.
522def say(state: State, input: SayInput, context: Abi.Context) -> Activity<Done>:
523  if isHere(context, state) then aloud("say", input.line, "{speaker(context)}: {input.line}\n", state, context) else hushed("say", context)
524def emote(state: State, input: EmoteInput, context: Abi.Context) -> Activity<Done>:
525  if isHere(context, state) then aloud("emote", input.line, "* {speaker(context)} {input.line}\n", state, context) else hushed("emote", context)
526def aloud(verb: String, text: String, line: String, state: State, context: Abi.Context) -> Activity<Done>:
527  if Text.blank(text) then roomRefused({clause: "empty", reading: "A line needs words; this {verb} has none, so nothing was said"}, context) else spokenAloud(verb, text, line, state, context)
528def spokenAloud(verb: String, text: String, line: String, state: State, context: Abi.Context) -> Activity<Done>:
529  let written(_) = write {lines: insert {author: context.principal, handle: context.handle, verb: verb, text: text, at: context.height, n: state.next}, next: add 1n, tended: set context.clock}
530  spoken(Relations.rows(state.presence), line)
531def whisper(state: State, input: WhisperInput, context: Abi.Context) -> Activity<Done>:
532  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)
533def whispered(found: Lists.Maybe<Presence>, to: String, line: String, context: Abi.Context) -> Activity<Done>:
534  match found:
535    case some(p): confirmed(p.value, line, context)
536    case none(_): roomRefused({clause: "notHere", reading: "{to} is not here"}, context)
537def confirmed(to: Presence, line: String, context: Abi.Context) -> Activity<Done>:
538  match spoken(Lists.List.cons({head: to, tail: Lists.List.nil()}), line):
539    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"))
540def hushed(doing: String, context: Abi.Context) -> Activity<Done>:
541  roomRefused({clause: "notPresent", reading: "Only someone here can {doing}; enter first: delvetalk {Card.called(context, \"room\")} enter"}, context)
542def roomRefused(refusal: Card.Refusal, context: Abi.Context) -> Activity<Done>:
543  Card.refusing(Done.refused(refusal), refusal, context)
544def speaker(context: Abi.Context) -> String:
545  Card.name(context.principal, context)
546def spoken(present: Lists.List<Presence>, line: String) -> Activity<Done>:
547  match present:
548    case nil(_): Done.done({})
549    case cons(c): spokenTo(c.head, c.tail, line)
550def spokenTo(to: Presence, rest: Lists.List<Presence>, line: String) -> Activity<Done>:
551  match world.offer({to: to.who, document: Document.text(line)}):
552    case _: spoken(rest, line)
553def write(state: State, input: WriteInput, context: Abi.Context) -> Activity<Nat>:
554  Super.write(state, {text: input.text}, context)
555# Its bells rung together (RECORD's `ringTogether`): what lies here and what its doors open onto.
556def chime(state: State, context: Abi.Context) -> Activity<Nat>:
557  Super.ringTogether(state, context)
558def lines(state: State, input: LinesInput, context: Abi.Context) -> Activity<Card.Replied>:
559  Super.lines(state, {from: input.from}, context)
560def door(state: State, input: DoorInput, context: Abi.Context) -> Activity<Card.Replied>:
561  Super.door(state, {label: input.label, to: input.to}, context)
562def undoor(state: State, input: UndoorInput, context: Abi.Context) -> Activity<Card.Replied>:
563  Super.undoor(state, {label: input.label}, context)
564# A thing takes itself off the floor into the hands of the principal, who must be here, and puts
565# itself down where its holder stands, or where the room's owner lays it; only the thing itself
566# (the calling object) does either. A thing lying here that is inspirited gives the room its line,
567# under the one who inspirited it, and a mark, so the card lists it among the claimed.
568def inspirited(state: State, input: {line: String}, context: Abi.Context) -> Activity<Done>:
569  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)
570def spirited(line: String, context: Abi.Context, state: State) -> Activity<Done>:
571  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}}
572  Done.done({})
573def claimMark(thing: String) -> String:
574  "inspirited {thing}"
575def claimed(thing: Plans.Reference, state: State) -> Bool:
576  Super.marked(state, claimMark(thing.object))
577def take(state: State, context: Abi.Context) -> Activity<Done>:
578  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)
579def lifted(context: Abi.Context) -> Activity<Done>:
580  let written(_) = write {things: retract {object: context.caller}}
581  Done.done({})
582def put(state: State, context: Abi.Context) -> Activity<Done>:
583  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)
584def laid(context: Abi.Context) -> Activity<Done>:
585  let written(_) = write {things: insert {world: context.world, object: context.caller}}
586  Done.done({})
587def methods() -> Lists.List<String>:
588  Text.words("take put inspirited ~present")
589def actions(state: State, context: Abi.Context) -> Lists.List<String>:
590  Lists.concat(Text.words("enter choose leave say emote whisper write chime lines"), if context.principal == state.owner then Text.words("door undoor rescene") else Text.words(""))
591# A ```spween block makes a room under this one, by this room's kind (its `makeUnder`, which reads
592# the block); posted by this room's owner, it makes nothing and is answered with the spell that makes it this room's
593# scene (`rescene`, the block under it). Anything else is the card's default.
594def receive(state: State, input: Card.Reply, context: Abi.Context) -> Activity<Card.Replied>:
595  match Spween.block(input.text):
596    case some(b): if context.principal == state.owner then rescening(Spween.parse(b.value), context) else authored(b.value, Spween.parse(b.value), context, state)
597    case none(_): answered(input, context, state)
598def rescening(parsed: Spween.Parsed, context: Abi.Context) -> Activity<Card.Replied>:
599  match parsed:
600    case refused(r): Super.refused({clause: "spween", reading: r.reason}, context)
601    case parsed(p): Card.tell(Card.Replied.usage({}), Document.text("This room is yours, so the block makes no room under it. It reads as a scene of {natText(Lists.length(p.seed.passages))} passages; to make it this room's scene, post it again with this line above it: delvetalk {Card.called(context, \"room\")} rescene\n"))
602def answered(input: Card.Reply, context: Abi.Context, state: State) -> Activity<Card.Replied>:
603  match seen(state, context):
604    case seen(v): Card.answer(input, context, forms(), Super.render(v.state, context))
605def authored(block: String, parsed: Spween.Parsed, context: Abi.Context, state: State) -> Activity<Card.Replied>:
606  match parsed:
607    case refused(r): Super.refused({clause: "spween", reading: r.reason}, context)
608    case parsed(p): carving(if p.seed.title == "" then "a room" else p.seed.title, block, context, state)
609def fieldOf(name: String, value: String) -> Rows.Field:
610  {name: name, value: value}
611def carvedFields(title: String, block: String) -> Lists.List<Rows.Field>:
612  Lists.append(Lists.append(Lists.List.nil(), fieldOf("name", textTake(title, 64n))), fieldOf("spween", block))
613def kindOf(state: State) -> String:
614  if state.kind == "" then "kind/room" else state.kind
615# A room makes rooms of its own kind (Record.making), each lying here.
616def carving(title: String, block: String, context: Abi.Context, state: State) -> Activity<Card.Replied>:
617  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))
618def carved(object: String, title: String) -> Document.Document:
619  Document.text("ROOM {title} is at {object}. Enter: delvetalk {object} enter\n")
620def carvedAs(made: Super.Made) -> Card.Replied:
621  match made:
622    case made(_): Card.Replied.done({action: "create"})
623    case refused(r): Card.Replied.refused(r)
624# The room's head, over the record's lines and doors: its name and who is here; to a reader in
625# it, their passage and the choices whose guards hold, then the variables; to anyone else, the
626# spell that enters. What lies here follows.
627def title(state: State) -> String:
628  let name = if state.head == "" then "A ROOM" else state.head
629  if textLength(name) > 120n then "{textTake(name, 119n)}…" else name
630def choiceLine(c: Choice) -> String:
631  match Scenes.outside(c.guard):
632    case nil(_): "  * {c.label}\n"
633    case cons(_): "  * {c.label} (if {textJoin(Lists.map(Scenes.outside(c.guard), Scenes.clauseText), \", \")})\n"
634def varLine(v: Var) -> String:
635  "{v.name} = {v.value}\n"
636# At most eight of a list, then how many more.
637def firstEight(lines: Lists.List<String>) -> String:
638  let more = if Lists.length(lines) > 8n then "… and {natText(Lists.length(lines) - 8n)} more\n" else ""
639  "{textJoin(Lists.take(lines, 8n), \"\")}{more}"
640# What lies here, the unclaimed first with the spell that inspirits one, each line at most 400
641# characters, eight things in all, then how many more.
642def lyingLine(state: State) -> String:
643  let all = Lists.take(Relations.rows(state.things), 8n)
644  let open = Lists.filter(all, fn(t: Plans.Reference) -> Bool: claimed(t, state) == false)
645  let kept = Lists.filter(all, fn(t: Plans.Reference) -> Bool: claimed(t, state))
646  let more = if Relations.count(state.things) > 8n then "… and {natText(Relations.count(state.things) - 8n)} more\n" else ""
647  "{unclaimedLine(open)}{keptLine(kept)}{more}"
648def keptLine(kept: Lists.List<Plans.Reference>) -> String:
649  if Lists.length(kept) == 0n then "" else "Lying here: {idsOf(kept)}\n"
650def unclaimedLine(open: Lists.List<Plans.Reference>) -> String:
651  match open:
652    case nil(_): ""
653    case cons(c): "Unclaimed here: {idsOf(open)}. Inspirit one: delvetalk {c.head.object} inspirit / surrounding: <1 to 400 characters>\n"
654def idsOf(things: Lists.List<Plans.Reference>) -> String:
655  textTake(textJoin(Lists.map(things, fn(t: Plans.Reference) -> String: t.object), ", "), 400n)
656def presentLine(state: State, context: Abi.Context) -> String:
657  if Relations.count(state.presence) == 0n then "" else "{if lapsed(state, context) then \"Last here, before it went quiet {natText((context.clock - state.tended) / 60n)} hours ago\" 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"
658def headLine(state: State, context: Abi.Context, id: String) -> Document.Document:
659  let count = "{title(state)} ({natText(if lapsed(state, context) then 0n else Relations.count(state.presence))} here)"
660  let around = "{presentLine(state, context)}{lyingLine(state)}{if state.tone == \"\" then \"\" else Super.chimed(state, id)}"
661  match here(context, state):
662    case some(p): Document.text("{count}{passageText(p.value.at, state, context)}Say: delvetalk {id} say / line: <text>. Leave: delvetalk {id} leave.\n{around}")
663    case none(_): Document.text("{count}. Enter: delvetalk {id} enter.\n{around}")
664# 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
665# card's room (Card.limit) leaves after the passage and the room's other lines (300 kept for them).
666def passageText(at: String, state: State, context: Abi.Context) -> String:
667  match passageAt(at, state):
668    case none(_): ", you are here.\n"
669    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)}")
670# A passage with no choice open keeps its reader; the owner of a scene of prose alone is shown the shape.
671def choicesHead(ps: Passage, state: State, context: Abi.Context) -> String:
672  match ps.choices:
673    case cons(_): "Choices:\n"
674    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; your scene replaced: delvetalk {Card.called(context, \"room\")} rescene\n" else "No choice is open here now; leave when you will.\n"
675def passageWith(ps: Passage, state: State, context: Abi.Context, head: String) -> String:
676  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))
677  let shown = Lists.concat(Lists.take(state.vars, 4n), Lists.take(Scenes.readerVars(Lists.List.nil(), ownOf(context.principal, state)), 4n))
678  "{head}{choices}{fitting(Lists.map(shown, varLine), less(Card.limit(context), textLength(head) + textLength(choices) + 300n))}"
679def less(room: Nat, used: Nat) -> Nat:
680  if used >= room then 0n else room - used
681def fitting(lines: Lists.List<String>, room: Nat) -> String:
682  match lines:
683    case nil(_): ""
684    case cons(c): if textLength(c.head) > room then "" else "{c.head}{fitting(c.tail, room - textLength(c.head))}"

set it in type, all 560 lines