{name}

1layer over ./Kind.obend
2edition ObjectiveBend 1
3import ./Abi.obend as Abi
4import ./List.obend as Lists
5import ./Form.obend as Form
6import ./Rows.obend as Rows
7type State = Super.State
8form make:
9  name: text 1..64
10  haunts: text 1..128
11  tide: text 1..128
12def make(state: State, input: MakeInput, context: Abi.Context) -> Activity<Super.Done>:
13  Super.making(state, Lists.List.cons({head: {name: "name", value: input.name}, tail: Lists.List.cons({head: {name: "haunts", value: input.haunts}, tail: Lists.List.cons({head: {name: "tide", value: input.tide}, tail: Lists.List.nil()})})}), "", context)
14form place:
15  name: text 1..64
16  haunts: text 1..128
17  tide: text 1..128
18  id: text 1..64
19def place(state: State, input: PlaceInput, context: Abi.Context) -> Activity<Super.Done>:
20  Super.making(state, Lists.List.cons({head: {name: "name", value: input.name}, tail: Lists.List.cons({head: {name: "haunts", value: input.haunts}, tail: Lists.List.cons({head: {name: "tide", value: input.tide}, tail: Lists.List.cons({head: {name: "id", value: input.id}, tail: Lists.List.nil()})})})}), "", context)

Each thing of this kind runs this layer over what the kind is of.

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 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"