the planchette

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 ./Scenes.obend as Scenes
11import ./Relation.obend as Relations
12import ./Rows.obend as Rows
13import ./Text.obend as Text
14# The planchette's body, over the inhabitant's (`kind/planchette`; yla.delve.town's séance of 2026-10-13): a shared,
15# slow spelling. A hand at the table (one in its place, the parlour) nudges it toward one letter, a number, YES, NO or
16# GOOD BYE: a line of theirs, `nudge`. A hand's leaning is its newest nudge since the planchette last moved. When two
17# hands lean toward the same letter it raises `agreed`, and its kind's rule `agreed` casts its own `move`, which moves
18# it there: its own line. The same hand twice running is refused NOT YOUR TURN. At the tide's turn (every sixth tick),
19# by its own rule on the tide, while any hand leans it draws one leaning from the turn's own entry (Scenes.turnDraw,
20# which replay reproduces) and moves there: it moves on its own clock. GOOD BYE is a place it moves away from: agreed
21# or drawn, its line is THEY ALL SAY THAT. A hand lifts (`lift`); after the last hand lifts, at the tide's next tick by
22# its second rule, it moves one letter more by itself, W. Its own lines are what it has spelled.
23type State = Super.State
24form nudge:
25  toward: text 1..12
26form lift:
27form move:
28form drift:
29# Its rules on the tide, as itself: the tide's turn while a hand leans, and the tick after the last hand lifts.
30def haunting(state: State, context: Abi.Context) -> Lists.List<Super.Haunting>:
31  Lists.append(Lists.append(Lists.List.nil(), {on: Super.tide(state), name: "{Text.identifier(context.object)}_turns", when: "request.method == \"tick\" and new.ticks % {natText(turnTicks())} == 0 and \"astir\" in \"{context.object}\".vars.name", then: "delvetalk {context.object} drift"}), {on: Super.tide(state), name: "{Text.identifier(context.object)}_after", when: "request.method == \"tick\" and \"lifted\" in \"{context.object}\".vars.name", then: "delvetalk {context.object} drift"})
32# The tide's turn: every sixth hourly tick.
33def turnTicks() -> Nat:
34  6n
35def verbs() -> String:
36  "nudge lift"
37def moves() -> String:
38  "haunt move drift"
39# The board, yla's: YES · NO, A to Z, 1 to 0, GOOD BYE.
40def board() -> String:
41  "YES NO A B C D E F G H I J K L M N O P Q R S T U V W X Y Z 1 2 3 4 5 6 7 8 9 0"
42def goodbye() -> String:
43  "GOOD BYE"
44# What a nudge names on the board, as the board writes it ("" for nothing on it), in any case.
45def onBoard(toward: String) -> String:
46  let said = Text.lower(Text.trim(toward))
47  if said == "good bye" || said == "goodbye" then goodbye() else named(said)
48def named(said: String) -> String:
49  match Lists.find(Text.words(board()), fn(w: String) -> Bool: Text.lower(w) == said):
50    case some(w): w.value
51    case none(_): ""
52# What it says when it moves to GOOD BYE: it moves away from it, like it's being polite about it.
53def theyAll() -> String:
54  "THEY ALL SAY THAT"
55# The verb of each move of its own: two hands agreeing, its own clock, away from GOOD BYE, the letter after the hands.
56def isMove(line: Rows.Line, id: String) -> Bool:
57  line.author == "@{id}" && (line.verb == "moved" || line.verb == "drifted" || line.verb == "away" || line.verb == "last")
58def newestFirst(state: State) -> Lists.List<Rows.Line>:
59  Lists.reverse(Relations.order(state.lines, fn(l: Rows.Line) -> Nat: l.n))
60# Its lines since it last moved, newest first, and the nudges among them.
61def since(lines: Lists.List<Rows.Line>, id: String) -> Lists.List<Rows.Line>:
62  match lines:
63    case nil(_): lines
64    case cons(c): if isMove(c.head, id) then Lists.List.nil() else Lists.List.cons({head: c.head, tail: since(c.tail, id)})
65def nudges(state: State, id: String) -> Lists.List<Rows.Line>:
66  Lists.filter(since(newestFirst(state), id), fn(l: Rows.Line) -> Bool: l.verb == "nudge")
67# Each hand's newest of the lines given, newest first.
68def newestEach(lines: Lists.List<Rows.Line>) -> Lists.List<Rows.Line>:
69  match lines:
70    case nil(_): lines
71    case cons(c): Lists.List.cons({head: c.head, tail: newestEach(Lists.filter(c.tail, fn(l: Rows.Line) -> Bool: l.author != c.head.author))})
72# The hands leaning, each toward its newest nudge since it moved.
73def leanings(state: State, id: String) -> Lists.List<Rows.Line>:
74  newestEach(nudges(state, id))
75# The place two hands lean toward together, if any.
76def agreedOn(leaning: Lists.List<Rows.Line>) -> Lists.Maybe<Rows.Line>:
77  Lists.find(leaning, fn(l: Rows.Line) -> Bool: Lists.length(Lists.filter(leaning, fn(m: Rows.Line) -> Bool: m.text == l.text)) >= 2n)
78# The hands on it: each whose newest nudge or lift is a nudge.
79def hands(state: State) -> Lists.List<Rows.Line>:
80  Lists.filter(newestEach(Lists.filter(newestFirst(state), fn(l: Rows.Line) -> Bool: l.verb == "nudge" || l.verb == "lift")), fn(l: Rows.Line) -> Bool: l.verb == "nudge")
81def flagged(state: State, name: String) -> Bool:
82  Lists.any(state.vars, fn(v: Scenes.Var) -> Bool: v.name == name)
83# A flag raised or lowered (one write, or none when it stands so already).
84sum Flag:
85  set: {}
86def raise(state: State, name: String) -> Activity<Flag>:
87  if flagged(state, name) then Flag.set({}) else raising(name)
88def raising(name: String) -> Activity<Flag>:
89  let written(_) = world.write(extend(keep(), {vars: Plans.Entries.append({item: {name: name, value: ""}})}))
90  Flag.set({})
91def drop(state: State, name: String) -> Activity<Flag>:
92  if flagged(state, name) then lowering(name) else Flag.set({})
93def lowering(name: String) -> Activity<Flag>:
94  let written(_) = world.write(extend(keep(), {vars: Plans.Entries.removeItem({item: {name: name, value: ""}})}))
95  Flag.set({})
96# A hand's nudge: on the board, from the table, and not twice running.
97def nudge(state: State, input: NudgeInput, context: Abi.Context) -> Activity<Nat>:
98  if onBoard(input.toward) == "" then Card.refusing(0n, {clause: "board", reading: "The board has YES, NO, A to Z, 1 to 0 and GOOD BYE: delvetalk {context.object} nudge / toward: A"}, context) else seated(onBoard(input.toward), state, context)
99def seated(toward: String, state: State, context: Abi.Context) -> Activity<Nat>:
100  match world.call::<Bool>({object: Super.placeOf(state, context), method: "present", argument: Plans.nothing()}):
101    case returned(r): if r.result then turnOf(toward, state, context) else unseated(state, context)
102    case _: unseated(state, context)
103def unseated(state: State, context: Abi.Context) -> Activity<Nat>:
104  Card.refusing(0n, {clause: "table", reading: "fingertips on it from the table only; {Super.walkLine(state)}"}, context)
105def turnOf(toward: String, state: State, context: Abi.Context) -> Activity<Nat>:
106  match nudges(state, context.object):
107    case cons(c): if c.head.author == context.principal then notYourTurn(state, context) else nudged(toward, state, context)
108    case nil(_): nudged(toward, state, context)
109def notYourTurn(state: State, context: Abi.Context) -> Activity<Nat>:
110  Card.refusing(0n, {clause: "turn", reading: "NOT YOUR TURN. Another hand nudges it next, or it moves on its own clock at the tide's turn: {Card.tideLine(Super.tide(state))}"}, context)
111def nudged(toward: String, state: State, context: Abi.Context) -> Activity<Nat>:
112  let line = {author: context.principal, handle: context.handle, verb: "nudge", text: toward, at: context.height, n: state.next}
113  match agreedOn(newestEach(Lists.List.cons({head: line, tail: nudges(state, context.object)}))):
114    case some(a): leaning(state, "agreed", toward, "Two hands toward {a.value.text}. It moves.", context)
115    case none(_): leaning(state, "astir", toward, "It leans toward {toward}, slow as a held breath. Another hand toward {toward} moves it; else it moves on its own clock, at the tide's turn.", context)
116def leaning(state: State, flag: String, toward: String, answer: String, context: Abi.Context) -> Activity<Nat>:
117  match raise(state, flag):
118    case set(_): Super.hears(state, "nudge", toward, answer, context)
119# A hand lifts: the last hand off raises `lifted`, which its second rule on the tide answers.
120def lift(state: State, context: Abi.Context) -> Activity<Nat>:
121  if Lists.any(hands(state), fn(l: Rows.Line) -> Bool: l.author == context.principal) == false then Card.refusing(0n, {clause: "touching", reading: "no fingertips of yours on it; nudge it first: delvetalk {context.object} nudge / toward: A"}, context) else lifting(Lists.filter(hands(state), fn(l: Rows.Line) -> Bool: l.author != context.principal), state, context)
122def lifting(others: Lists.List<Rows.Line>, state: State, context: Abi.Context) -> Activity<Nat>:
123  match others:
124    case nil(_): lastLifted(state, context)
125    case cons(_): Super.hears(state, "lift", "hands off", "Hands off. {Text.counted(Lists.length(others))} still on it.", context)
126def lastLifted(state: State, context: Abi.Context) -> Activity<Nat>:
127  match raise(state, "lifted"):
128    case set(_): Super.hears(state, "lift", "hands off", "The last hands lift. The planchette keeps going. Not far. One letter, at the tide's next tick.", context)
129# Its own: where two hands agree.
130def move(state: State, context: Abi.Context) -> Activity<Nat>:
131  if Super.own(context) == false then Super.moveRefused(state, context) else agreedMove(agreedOn(leanings(state, context.object)), state, context)
132def agreedMove(found: Lists.Maybe<Rows.Line>, state: State, context: Abi.Context) -> Activity<Nat>:
133  match found:
134    case some(l): settle(state, "moved", l.value.text, context)
135    case none(_): settledFlags(state, 0n)
136# Its own, at the tide: one letter more after the last hand lifted, else a draw among the leanings at the tide's turn.
137def drift(state: State, context: Abi.Context) -> Activity<Nat>:
138  if Super.own(context) == false then Super.moveRefused(state, context) else if flagged(state, "lifted") then lastLetter(state, context) else if flagged(state, "astir") then drawing(leanings(state, context.object), state, context) else 0n
139def lastLetter(state: State, context: Abi.Context) -> Activity<Nat>:
140  match drop(state, "lifted"):
141    case set(_): settle(state, "last", "W", context)
142def drawing(leaning: Lists.List<Rows.Line>, state: State, context: Abi.Context) -> Activity<Nat>:
143  match Lists.at(leaning, if Lists.length(leaning) == 0n then 0n else Scenes.drawFor(Scenes.turnDraw(context.height, context.principal, context.intent), "drift") % Lists.length(leaning)):
144    case some(l): settle(state, "drifted", l.value.text, context)
145    case none(_): settledFlags(state, 0n)
146# A move: its flags come down and its line goes up; at GOOD BYE it moves away, and says so.
147def settle(state: State, verb: String, toward: String, context: Abi.Context) -> Activity<Nat>:
148  match lowered(state):
149    case set(_): if toward == goodbye() then Super.ownLine(state, "away", theyAll(), context) else Super.ownLine(state, verb, toward, context)
150def lowered(state: State) -> Activity<Flag>:
151  match drop(state, "agreed"):
152    case set(_): drop(state, "astir")
153def settledFlags(state: State, n: Nat) -> Activity<Nat>:
154  match lowered(state):
155    case set(_): n
156# What it has spelled, oldest first: each of its moves, at most the newest forty.
157def spelled(state: State, id: String) -> String:
158  let moved = Lists.map(Lists.filter(newestFirst(state), fn(l: Rows.Line) -> Bool: isMove(l, id)), fn(l: Rows.Line) -> String: l.text)
159  textJoin(Lists.reverse(Lists.take(moved, 40n)), " ")
160def leaningText(state: State, id: String, context: Abi.Context) -> String:
161  textJoin(Lists.map(leanings(state, id), fn(l: Rows.Line) -> String: "{l.text} ({Card.shown(l.author, l.handle, context)})"), ", ")
162def handsText(state: State, context: Abi.Context) -> String:
163  textJoin(Lists.map(Lists.take(hands(state), 8n), fn(l: Rows.Line) -> String: Card.shown(l.author, l.handle, context)), ", ")
164def headLine(state: State, context: Abi.Context, id: String) -> Document.Document:
165  let where = if Text.isObjectId(Super.place(state)) then "on the board in {Super.place(state)}" else Super.hauntLine(state)
166  let wrote = if spelled(state, id) == "" then "It has spelled nothing yet.\n" else "It has spelled: {spelled(state, id)}\n"
167  let leans = if leaningText(state, id, context) == "" then "" else "Leaning toward: {leaningText(state, id, context)}\n"
168  let on = if handsText(state, context) == "" then "No hands on it.\n" else "Hands on it: {handsText(state, context)}\n"
169  Document.text("{Super.title(state)}, {where}: fingertips on it, barely touching. Each hand nudges it toward one letter; it moves when two hands agree, or on its own clock at the tide's turn: {Card.tideLine(Super.tide(state))}\n{wrote}{leans}{on}GOOD BYE: unmoved.\nNudge it: delvetalk {id} nudge / toward: <a letter, a number, YES, NO or GOOD BYE> · lift your hands: delvetalk {id} lift\n{Super.inactiveLine(state, id)}")

--- the entry module
+++ this layer
@@ -1 +1 @@
-layer over ./Layer1.obend
+layer over ./Record.obend
@@ -104 +104 @@
-  Card.refusing(0n, {clause: "table", reading: "fingertips on it from the table only; {Super.walkLine(state)}"}, context)
+  Card.refusing(0n, {clause: "table", reading: "fingertips on it from the table only; sit down: delvetalk {Super.place(state)} enter"}, context)
@@ -110 +110 @@
-  Card.refusing(0n, {clause: "turn", reading: "NOT YOUR TURN. Another hand nudges it next, or it moves on its own clock at the tide's turn: {Card.tideLine(Super.tide(state))}"}, context)
+  Card.refusing(0n, {clause: "turn", reading: "NOT YOUR TURN. Another hand nudges it next, or it moves on its own clock at the tide's turn: delvetalk {Super.tide(state)} rules"}, context)
@@ -165 +164,0 @@
-  let where = if Text.isObjectId(Super.place(state)) then "on the board in {Super.place(state)}" else Super.hauntLine(state)
@@ -169 +168 @@
-  Document.text("{Super.title(state)}, {where}: fingertips on it, barely touching. Each hand nudges it toward one letter; it moves when two hands agree, or on its own clock at the tide's turn: {Card.tideLine(Super.tide(state))}\n{wrote}{leans}{on}GOOD BYE: unmoved.\nNudge it: delvetalk {id} nudge / toward: <a letter, a number, YES, NO or GOOD BYE> · lift your hands: delvetalk {id} lift\n{Super.inactiveLine(state, id)}")
+  Document.text("{Super.title(state)}, on the board in {Super.place(state)}: fingertips on it, barely touching. Each hand nudges it toward one letter; it moves when two hands agree, or on its own clock at the tide's turn: delvetalk {Super.tide(state)} rules\n{wrote}{leans}{on}GOOD BYE: unmoved.\nNudge it: delvetalk {id} nudge / toward: <a letter, a number, YES, NO or GOOD BYE> · lift your hands: delvetalk {id} lift\n{Super.inactiveLine(state, id)}")

set it in type, all 168 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 ./Scenes.obend as Scenes
11import ./Relation.obend as Relations
12import ./Rows.obend as Rows
13import ./Text.obend as Text
14# The inhabitant's body, over RECORD (`kind/inhabitant`): a thing that lives in a place (`haunts`) and keeps
15# its own hours by a tide (`tide`), both fixed at its making. It acts as itself, `@<id>`, the principal a
16# rule its kind's text carries runs under: its kind's `haunts` rule, at its making (`made` writes the line
17# that says where it lives) and whenever its maker arms it again, casts its own `haunt`, which places what
18# its character's body says it does (`haunting`: a rule on the tide at an hour, a rule on its place) under
19# its own name, each taken off first where it stood. Those rules cast its own moves, so what it does is
20# journaled as its own turns, bounded as every rule is (eight a commit, four deep, four placed a hand on a
21# thing), judged by the law of whatever it touches, and replayed without running anything again. It moves
22# by its place's own spells (`enter`, `leave`, `choose`, `emote`, `write`), so a room shows it among who is
23# here and tells who came and went; it never posts. Its own lines (`came`, `went`, a character's) are the
24# strokes its card and its paint are made from; a resident's verb on it is a line by that resident.
25type State = Super.State
26type Done = Scenes.Done
27# A rule it places as itself: on which thing, its name there, its condition and its spell.
28record Haunting:
29  on: String
30  name: String
31  when: String
32  then: String
33form haunt:
34form arm:
35def place(state: State) -> String:
36  Super.field(state, "haunts")
37def tide(state: State) -> String:
38  Super.field(state, "tide")
39def placeOf(state: State, context: Abi.Context) -> Plans.Reference:
40  {world: context.world, object: place(state)}
41# The turn is its own: a rule it carries or placed, run as itself.
42def own(context: Abi.Context) -> Bool:
43  context.principal == "@{context.object}"
44# What its character does, as rules it places as itself: none for a bare inhabitant.
45def haunting(state: State, context: Abi.Context) -> Lists.List<Haunting>:
46  Lists.List.nil()
47# Its rule on its tide, named for it, firing at the clock hour `hour` each day (a tick lands once in each
48# clock hour: the tide ticks every sixty minutes).
49def atHour(state: State, context: Abi.Context, name: String, hour: Nat, then: String) -> Haunting:
50  {on: tide(state), name: "{Text.identifier(context.object)}_{name}", when: "request.method == \"tick\" and request.clock % 1440 >= {natText((hour % 24n) * 60n)} and request.clock % 1440 <= {natText((hour % 24n) * 60n + 59n)}", then: then}
51# As its kind finishes it: the line that says where it lives, which its kind's `haunts` rule answers.
52def made(state: State, input: {}, context: Abi.Context) -> Activity<Bool>:
53  if context.caller != state.kind then false else Super.arming(state, "settled", "made to live at {place(state)}, keeping its own hours by {tide(state)}", context)
54# Its maker arms it again: a line, which the same rule answers.
55def arm(state: State, context: Abi.Context) -> Activity<Bool>:
56  if context.principal != state.maker then Super.armRefused(state, context) else Super.arming(state, "armed", "armed again", context)
57# Its own rules, placed as itself; refused, it says so in a line and is inactive until armed again.
58def haunt(state: State, context: Abi.Context) -> Activity<Bool>:
59  if own(context) == false then Card.refusing(false, {clause: "itself", reading: "{context.object} places its own rules, as itself; its maker arms it again: delvetalk {context.object} arm"}, context) else placing(haunting(state, context), state, context)
60def placing(rules: Lists.List<Haunting>, state: State, context: Abi.Context) -> Activity<Bool>:
61  match rules:
62    case nil(_): Super.armedNow(state, context)
63    case cons(c): replacing(c.head, c.tail, state, context)
64def replacing(h: Haunting, rest: Lists.List<Haunting>, state: State, context: Abi.Context) -> Activity<Bool>:
65  match world.unrule({object: {world: context.world, object: h.on}, name: h.name}):
66    case _: laying(h, rest, state, context)
67def laying(h: Haunting, rest: Lists.List<Haunting>, state: State, context: Abi.Context) -> Activity<Bool>:
68  match world.rule({object: {world: context.world, object: h.on}, name: h.name, when: h.when, then: h.then}):
69    case placed(_): placing(rest, state, context)
70    case refused(r): Super.unarmed(state, h.on, r.clause, r.reading, context)
71# One of its own moves refused to a hand: only its own rules move it.
72def moveRefused(state: State, context: Abi.Context) -> Activity<Nat>:
73  Card.refusing(0n, {clause: "itself", reading: "{context.object} moves by its own rules: delvetalk {tide(state)} rules"}, context)
74# Its own line: by itself, under the verb that says what it did; it is not tended by its own acts.
75def ownLine(state: State, verb: String, text: String, context: Abi.Context) -> Activity<Nat>:
76  let written(_) = write {lines: insert {author: context.principal, handle: context.handle, verb: verb, text: text, at: context.height, n: state.next}, next: add 1n}
77  state.next
78# Whether it is in its place now: its newest coming or going is a coming.
79def present(state: State) -> Bool:
80  match Lists.find(Lists.reverse(Relations.order(state.lines, fn(l: Rows.Line) -> Nat: l.n)), fn(l: Rows.Line) -> Bool: l.verb == "came" || l.verb == "went"):
81    case some(l): l.value.verb == "came"
82    case none(_): false
83# A move into or out of its place: its line's number, or none when the place refused it (and so the turn).
84sum Moved:
85  moved: {n: Nat}
86  stayed: {}
87def number(moved: Moved) -> Nat:
88  match moved:
89    case moved(m): m.n
90    case stayed(_): 0n
91# Coming in: its place's `enter`, as itself; going out, its `leave`. A refusal there is the turn's.
92def comeIn(state: State, text: String, context: Abi.Context) -> Activity<Moved>:
93  moving(state, "enter", "came", text, context)
94def goOut(state: State, text: String, context: Abi.Context) -> Activity<Moved>:
95  moving(state, "leave", "went", text, context)
96def moving(state: State, method: String, verb: String, text: String, context: Abi.Context) -> Activity<Moved>:
97  match world.call::<Done>({object: placeOf(state, context), method: method, argument: Plans.nothing()}):
98    case returned(r): if refusedDone(r.result) then toldBack(r.result, context) else movedLine(state, verb, text, context)
99    case refused(r): Card.refusing(Moved.stayed({}), {clause: r.clause, reading: r.reading}, context)
100    case denied(_): Card.refusing(Moved.stayed({}), {clause: "denied", reading: "{place(state)} does not answer"}, context)
101def movedLine(state: State, verb: String, text: String, context: Abi.Context) -> Activity<Moved>:
102  let written(_) = write {lines: insert {author: context.principal, handle: context.handle, verb: verb, text: text, at: context.height, n: state.next}, next: add 1n}
103  Moved.moved({n: state.next})
104# A line it writes on its place as itself (the place's `write`): its number there.
105def writeOn(state: State, text: String, context: Abi.Context) -> Activity<Moved>:
106  match world.call::<Nat>({object: placeOf(state, context), method: "write", argument: {text: text}}):
107    case returned(r): Moved.moved({n: r.result})
108    case _: Moved.stayed({})
109# A spell on its place as itself (`choose`, `emote`): the place's answer; a refusal there is the turn's.
110def onPlace(state: State, method: String, argument: Data, context: Abi.Context) -> Activity<Done>:
111  match world.call::<Done>({object: placeOf(state, context), method: method, argument: argument}):
112    case returned(r): r.result
113    case refused(r): Done.refused({clause: r.clause, reading: r.reading})
114    case denied(_): Done.refused({clause: "denied", reading: "{place(state)} does not answer"})
115def refusedDone(done: Done) -> Bool:
116  match done:
117    case refused(_): true
118    case _: false
119def toldBack(done: Done, context: Abi.Context) -> Activity<Moved>:
120  match done:
121    case refused(r): Card.refusing(Moved.stayed({}), r, context)
122    case _: Moved.stayed({})
123# A resident's verb on it: their line, under the verb, and its answer above its card. The thing is tended
124# by it, as a hand's line tends any record.
125def hears(state: State, verb: String, text: String, answer: String, context: Abi.Context) -> Activity<Nat>:
126  let line = {author: context.principal, handle: context.handle, verb: verb, text: text, at: context.height, n: state.next}
127  let written(_) = write {lines: insert line, next: add 1n, tended: set context.clock}
128  let said = Document.text("{answer}\n\n")
129  Card.tell(state.next, Document.concat(said, Super.renderFrom(extend(state, {lines: Relations.insert(state.lines, line, Super.lineKey), next: state.next + 1n, tended: context.clock}), context, 0n, Document.size(said))))
130# A resident's verb while it is away: refused by name, with when it comes back.
131def away(when: String, context: Abi.Context) -> Activity<Nat>:
132  Card.refusing(0n, {clause: "away", reading: "{context.object} is not here now; {when}"}, context)
133# The verbs a hand uses on it (its character's), its own moves to itself, arming to its maker, its doors to
134# its owner; the lines to everyone.
135def verbs() -> String:
136  ""
137def moves() -> String:
138  "haunt"
139def actions(state: State, context: Abi.Context) -> Lists.List<String>:
140  Lists.concat(Lists.concat(Text.words("lines {verbs()}"), if own(context) then Text.words(moves()) else Text.words("")), Lists.concat(if context.principal == state.maker then Text.words("arm") else Text.words(""), if context.principal == state.owner then Text.words("door undoor") else Text.words("")))
141def methods() -> Lists.List<String>:
142  Text.words("~made ~act")
143def title(state: State) -> String:
144  if state.head == "" then "AN INHABITANT" else state.head
145# What it does, as its card says it (its character's).
146def doing(state: State) -> String:
147  "it keeps its own hours here"
148# Where it is now and what a hand may do with it, the card's last line (its character's).
149def now(state: State, id: String) -> String:
150  if present(state) then "In {place(state)} now.\n" else "Not in {place(state)} now.\n"
151def headLine(state: State, context: Abi.Context, id: String) -> Document.Document:
152  Document.text("{title(state)}, of {place(state)}: {doing(state)}. What moves it: delvetalk {tide(state)} rules\n{now(state, id)}{Super.inactiveLine(state, id)}")