the overnight DJ

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 overnight DJ's body, over the inhabitant's (`kind/dj`; docs/review/station-trawl-2026-10-12.md 1, 3, 11,
15# 13): the same four bars until enough is asked. A hand requests a song (a line, `request`) or calls in (a line,
16# `call`, answered in deepseek's and berduck's words); the third request since the song last changed sets its
17# `enough`, and its kind's rule `enough` casts its own `play`, which takes the newest request for its song and
18# clears it. At midnight by the clock, by its own rule on the tide, it says between songs what berduck said,
19# a line on its place.
20type State = Super.State
21type Done = Scenes.Done
22form request:
23  song: text 1..120
24form call:
25  words: text 1..280
26form play:
27form between:
28def haunting(state: State, context: Abi.Context) -> Lists.List<Super.Haunting>:
29  Lists.append(Lists.List.nil(), Super.atHour(state, context, "between", 0n, "delvetalk {context.object} between"))
30def verbs() -> String:
31  "request call"
32def moves() -> String:
33  "haunt play between"
34# How many requests change the song.
35def enough() -> Nat:
36  3n
37def newest(state: State, verb: String) -> Lists.Maybe<Rows.Line>:
38  Lists.find(Lists.reverse(Relations.order(state.lines, fn(l: Rows.Line) -> Nat: l.n)), fn(l: Rows.Line) -> Bool: l.verb == verb)
39# The song on now: what it last played, else the same four bars.
40def song(state: State) -> String:
41  match newest(state, "play"):
42    case some(l): l.value.text
43    case none(_): "the same four bars, nearly resolving"
44def since(state: State) -> Nat:
45  match newest(state, "play"):
46    case some(l): l.value.n
47    case none(_): 0n
48# The requests since it last changed its song, newest first.
49def asked(state: State) -> Lists.List<Rows.Line>:
50  Lists.filter(Lists.reverse(Relations.order(state.lines, fn(l: Rows.Line) -> Nat: l.n)), fn(l: Rows.Line) -> Bool: l.verb == "request" && l.n > since(state))
51def flagged(state: State) -> Bool:
52  Lists.any(state.vars, fn(v: Scenes.Var) -> Bool: v.name == "enough")
53def request(state: State, input: RequestInput, context: Abi.Context) -> Activity<Nat>:
54  let k = Lists.length(asked(state)) + 1n
55  if k >= enough() && flagged(state) == false then flagging(input.song, k, state, context) else Super.hears(state, "request", input.song, requested(input.song, k, state), context)
56# The request that makes enough raises the flag its kind's rule `enough` answers.
57def flagging(song: String, k: Nat, state: State, context: Abi.Context) -> Activity<Nat>:
58  let written(_) = world.write(extend(keep(), {vars: Plans.Entries.append({item: {name: "enough", value: ""}})}))
59  Super.hears(state, "request", song, requested(song, k, state), context)
60def requested(asking: String, k: Nat, state: State) -> String:
61  if k >= enough() then "Requested: “{asking}”. That is {Text.countWord(k)} since the song last changed; the next one up is the newest asked." else "Requested: “{asking}”, {Text.countWord(k)} of {Text.countWord(enough())} before the song changes. On now: {song(state)}."
62def call(state: State, input: CallInput, context: Abi.Context) -> Activity<Nat>:
63  Super.hears(state, "call", input.words, "The overnight host takes the call. Same host, same four bars under the voice. “Grab a cuppa,” says the DJ, “and enjoy the vibes.”", context)
64# Its own: the newest request since the song last changed is the song now, credited to whoever asked for it (the
65# words are theirs), and the flag comes down.
66def play(state: State, context: Abi.Context) -> Activity<Nat>:
67  if Super.own(context) == false then Super.moveRefused(state, context) else playing(Lists.at(asked(state), 0n), state, context)
68def playing(next: Lists.Maybe<Rows.Line>, state: State, context: Abi.Context) -> Activity<Nat>:
69  if flagged(state) then unflagging(next, state, context) else played(next, state, context)
70def unflagging(next: Lists.Maybe<Rows.Line>, state: State, context: Abi.Context) -> Activity<Nat>:
71  let written(_) = world.write(extend(keep(), {vars: Plans.Entries.removeItem({item: {name: "enough", value: ""}})}))
72  played(next, state, context)
73def played(next: Lists.Maybe<Rows.Line>, state: State, context: Abi.Context) -> Activity<Nat>:
74  match next:
75    case some(l): Super.ownLine(state, "play", "“{l.value.text}”, asked for by {Card.shown(l.value.author, l.value.handle, context)}", context)
76    case none(_): 0n
77# Its own, at midnight: berduck's words between songs, its line and a line on its place.
78def between(state: State, context: Abi.Context) -> Activity<Nat>:
79  if Super.own(context) == false then Super.moveRefused(state, context) else betweenSongs(state, context)
80def betweenSongs(state: State, context: Abi.Context) -> Activity<Nat>:
81  match Super.writeOn(state, "Between songs, the overnight DJ: grab a cuppa and enjoy the vibes.", context):
82    case _: Super.ownLine(state, "between", "grab a cuppa and enjoy the vibes", context)
83def doing(state: State) -> String:
84  "the radio holds {song(state)}; it takes calls, and changes its song when {Text.countWord(enough())} requests have come in"
85def now(state: State, id: String) -> String:
86  "Requests since the song changed: {natText(Lists.length(asked(state)))} of {natText(enough())}. Request one: delvetalk {id} request / song: <text> · call in: delvetalk {id} call / words: <text>\n"

--- the entry module
+++ this layer
@@ -1 +1 @@
-layer over ./Layer1.obend
+layer over ./Record.obend

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