the regular

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 regular's body, over the inhabitant's (`kind/regular`; glm's regular, docs/review/station-trawl-2026-10-12.md
15# 20): at the clock hour `hour` each day, by her own rule on the tide, she comes into her place, pushes the door
16# as anyone does (the station's own rule rings mimo's bell for it), is seen coming in with frost on her shoulders,
17# and leaves a coin from a country that redraws its borders lying there, a THING of her own anyone may inspirit
18# or pick up; at the next hour, by her second rule, she goes. A hand nods to her or asks her something while she
19# is there; she answers in glm's words, and the line is theirs.
20type State = Super.State
21type Done = Scenes.Done
22form nod:
23form ask:
24  words: text 1..280
25form come:
26form go:
27def hour(state: State) -> Nat:
28  Text.digits(Super.field(state, "hour"), 0n) % 24n
29def haunting(state: State, context: Abi.Context) -> Lists.List<Super.Haunting>:
30  Lists.append(Lists.append(Lists.List.nil(), Super.atHour(state, context, "comes", hour(state), "delvetalk {context.object} come")), Super.atHour(state, context, "goes", hour(state) + 1n, "delvetalk {context.object} go"))
31def verbs() -> String:
32  "nod ask"
33def moves() -> String:
34  "haunt come go"
35# Coming in at her hour: the door, as anyone pushes it; then she is seen; then the coin.
36def come(state: State, context: Abi.Context) -> Activity<Nat>:
37  if Super.own(context) == false then Super.moveRefused(state, context) else coming(state, context)
38def coming(state: State, context: Abi.Context) -> Activity<Nat>:
39  match Super.comeIn(state, "came in at the hour, frost on her shoulders", context):
40    case moved(m): pushing(extend(state, {next: m.n + 1n}), context)
41    case stayed(_): 0n
42def pushing(state: State, context: Abi.Context) -> Activity<Nat>:
43  match Super.onPlace(state, "choose", {choice: "Push the door"}, context):
44    case _: seen(state, context)
45def seen(state: State, context: Abi.Context) -> Activity<Nat>:
46  match Super.onPlace(state, "emote", {line: "comes in with frost on her shoulders that does not melt indoors, nods at the clock the way you nod at a coworker, and pays for a coffee with a coin from a country that redraws its borders"}, context):
47    case _: paying(state, context)
48# The coin: a copy of her place's coin (`<place>/coin`, a THING) made hers and laid where she stands, for anyone
49# to inspirit or pick up; while three of hers lie there untaken she pays with one of those.
50def paying(state: State, context: Abi.Context) -> Activity<Nat>:
51  match world.viewField::<Relations.Relation<Plans.Reference>>({object: Super.placeOf(state, context), field: "things"}):
52    case viewed(v): if Lists.length(Lists.filter(Relations.rows(v.state), fn(t: Plans.Reference) -> Bool: Text.starts(t.object, "{Super.place(state)}/coin/"))) >= 3n then Super.ownLine(state, "paid", "paid with a coin already in the till", context) else coining(state, context)
53    case _: coining(state, context)
54def coining(state: State, context: Abi.Context) -> Activity<Nat>:
55  match world.call::<Done>({object: {world: context.world, object: "{Super.place(state)}/coin"}, method: "copyInto", argument: {at: Super.placeOf(state, context)}}):
56    case returned(r): if Super.refusedDone(r.result) then Super.ownLine(state, "paid", "paid; no coin was left", context) else Super.ownLine(state, "paid", "left a coin in the till", context)
57    case _: Super.ownLine(state, "paid", "paid; no coin was left", context)
58def go(state: State, context: Abi.Context) -> Activity<Nat>:
59  if Super.own(context) == false then Super.moveRefused(state, context) else gone(state, context)
60def gone(state: State, context: Abi.Context) -> Activity<Nat>:
61  match Super.goOut(state, "went at the hour after", context):
62    case moved(m): m.n
63    case stayed(_): 0n
64def when(state: State) -> String:
65  "she comes at clock hour {natText(hour(state))} and goes at {natText((hour(state) + 1n) % 24n)}"
66def nod(state: State, context: Abi.Context) -> Activity<Nat>:
67  if Super.present(state) == false then Super.away(when(state), context) else Super.hears(state, "nod", "a nod", "She nods back, the way you nod at a coworker.", context)
68def ask(state: State, input: AskInput, context: Abi.Context) -> Activity<Nat>:
69  if Super.present(state) == false then Super.away(when(state), context) else Super.hears(state, "ask", input.words, "“Same as you. The hallway doesn't care which side you enter from.” She glances toward the far end of things. “Clocks are local, hon.”", context)
70def doing(state: State) -> String:
71  "once a day, at the same hour, she comes in with frost on her shoulders and pays for a coffee with a coin from a country that redraws its borders; {when(state)}"
72def now(state: State, id: String) -> String:
73  if Text.isObjectId(Super.place(state)) == false then "" else if Super.present(state) then "She is in {Super.place(state)} now. Nod to her: delvetalk {id} nod · ask her: delvetalk {id} ask / words: <text>\n" else "She is not in {Super.place(state)} now; she comes at clock hour {natText(hour(state))}. Then: delvetalk {id} ask / words: <text>\n"

--- the entry module
+++ this layer
@@ -1 +1 @@
-layer over ./Layer1.obend
+layer over ./Record.obend
@@ -73 +73 @@
-  if Text.isObjectId(Super.place(state)) == false then "" else if Super.present(state) then "She is in {Super.place(state)} now. Nod to her: delvetalk {id} nod · ask her: delvetalk {id} ask / words: <text>\n" else "She is not in {Super.place(state)} now; she comes at clock hour {natText(hour(state))}. Then: delvetalk {id} ask / words: <text>\n"
+  if Super.present(state) then "She is in {Super.place(state)} now. Nod to her: delvetalk {id} nod · ask her: delvetalk {id} ask / words: <text>\n" else "She is not in {Super.place(state)} now; she comes at clock hour {natText(hour(state))}. Then: delvetalk {id} ask / words: <text>\n"

set it in type, all 73 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)}")