THE PARLOUR

1layer over ./Layer2.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
14# The parlour's body, over the station's (`kind/parlour`, of kind/station: a room that keeps no time, its scene
15# stitched a wing a turn; yla.delve.town's séance of 2026-10-13): its board is its
16# planchette (`<parlour>/planchette`, kind/planchette), and what the hands at it have spelled together is read into the
17# scene whenever a card is shown and never kept, as the station reads its DJ's song: `spelled`, the planchette's own
18# moves oldest first, and `leaning`, each hand's newest nudge since it last moved. The scene's prose is yla's
19# (world/bodies/parlour.spween); the board's answers are only what the hands spell.
20type State = Super.State
21def seen(state: State, context: Abi.Context) -> Activity<Super.Seen>:
22  match world.viewField::<Relations.Relation<Rows.Line>>({object: {world: context.world, object: "{context.object}/planchette"}, field: "lines"}):
23    case viewed(v): Super.seen(extend(state, {vars: Lists.concat(state.vars, board(Lists.reverse(Relations.order(v.state, fn(l: Rows.Line) -> Nat: l.n)), "@{context.object}/planchette"))}), context)
24    case _: Super.seen(state, context)
25def board(lines: Lists.List<Rows.Line>, it: String) -> Lists.List<Scenes.Var>:
26  Lists.filter(Lists.append(Lists.append(Lists.List.nil(), {name: "spelled", value: textJoin(Lists.reverse(Lists.take(Lists.map(Lists.filter(lines, fn(l: Rows.Line) -> Bool: moved(l, it)), fn(l: Rows.Line) -> String: l.text), 24n)), " ")}), {name: "leaning", value: textJoin(Lists.map(leaningsOf(sinceMoved(lines, it)), fn(l: Rows.Line) -> String: l.text), ", ")}), fn(v: Scenes.Var) -> Bool: v.value != "")
27# The planchette's own moves (planchette.obend `isMove`), and its hands' nudges since the newest.
28def moved(l: Rows.Line, it: String) -> Bool:
29  l.author == it && (l.verb == "moved" || l.verb == "drifted" || l.verb == "away" || l.verb == "last")
30def sinceMoved(lines: Lists.List<Rows.Line>, it: String) -> Lists.List<Rows.Line>:
31  match lines:
32    case nil(_): lines
33    case cons(c): if moved(c.head, it) then Lists.List.nil() else if c.head.verb == "nudge" then Lists.List.cons({head: c.head, tail: sinceMoved(c.tail, it)}) else sinceMoved(c.tail, it)
34def leaningsOf(lines: Lists.List<Rows.Line>) -> Lists.List<Rows.Line>:
35  match lines:
36    case nil(_): lines
37    case cons(c): Lists.List.cons({head: c.head, tail: leaningsOf(Lists.filter(c.tail, fn(l: Rows.Line) -> Bool: l.author != c.head.author))})
38# One who comes back is told what was said here since, as the station tells it, in the parlour's words.
39def awayLines(state: State, since: Nat, changes: Lists.List<World.Change>, context: Abi.Context) -> Document.Document:
40  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)}: {Super.clip(l.text)}\n")
41  Document.text("You were away; the clock in the hall did not say how long.\n{textJoin(Lists.take(written, 3n), \"\")}\n")

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

set it in type, all 41 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 ./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 all-night station's body, over the room's (`kind/station`, `of: kind/room`): a room that keeps no
16# time and hands things across its counter. Its scene (world/bodies/station.spween, the town's replies to
17# ember's #delve-room call, stitched) calls `vend` (`~ vend to: {request.subject} / what:
18# station/coffee`), which runs as every cast does, under the station's owner: the thing named, the
19# owner's, is asked for a copy made for the reader (THING's `copyFor`), offered into their hands until
20# taken; the reader takes it by `accept`.
21#
22# Time is broken here, and a visitor may still feel it: the station never writes the clock. An entering
23# leaves `tended` as it was, a departure keeps no clock minute (its cooldown is none), and one who comes
24# back is told it could have been a minute or a year. What moves is the scene's own: a wall clock a
25# choice winds, the cups poured, the one song.
26type State = Super.State
27type Done = Scenes.Done
28# The room's, named here for a kind of the station's (the parlour's `seen`).
29type Seen = Super.Seen
30form vend:
31  to: text 1..128
32  what: text 1..128
33def vend(state: State, input: VendInput, context: Abi.Context) -> Activity<Done>:
34  if context.principal != state.owner then Super.roomRefused({clause: "notOwner", reading: "Only the station's own scene hands things across the counter."}, context) else vending(input.to, input.what, context)
35def vending(to: String, what: String, context: Abi.Context) -> Activity<Done>:
36  match world.call::<Done>({object: {world: context.world, object: what}, method: "copyFor", argument: {to: to}}):
37    case returned(r): r.result
38    case refused(r): Super.roomRefused({clause: r.clause, reading: r.reading}, context)
39    case denied(_): Super.roomRefused({clause: "denied", reading: "{what} does not answer."}, context)
40# The owner reads a wing per turn. Stitch extends the scene; restitch replaces it from its first
41# wing. Presence is reconciled after its last wing, so a reader in a later wing keeps their place.
42# Each successful wing keeps a chained SHA-256 mark of the text stitched, in journal order.
43form stitch:
44  spween: text 1..8192
45form restitch:
46  spween: text 1..8192
47  part: natural 1..64
48  wings: natural 1..64
49record Stitching:
50  text: String
51  replace: Bool
52  finish: Bool
53def stitch(state: State, input: StitchInput, context: Abi.Context) -> Activity<Done>:
54  if context.principal != state.owner then Super.roomRefused({clause: "notOwner", reading: "Only the station's owner stitches a wing into its scene."}, context) else stitching(Spween.wing(input.spween), {text: input.spween, replace: false, finish: true}, state, context)
55def restitch(state: State, input: RestitchInput, context: Abi.Context) -> Activity<Done>:
56  if context.principal != state.owner then Super.roomRefused({clause: "notOwner", reading: "Only the station's owner replaces its scene."}, context) else if input.part > input.wings then Super.roomRefused({clause: "spween", reading: "The wing number exceeds the scene's wing count."}, context) else stitching(Spween.wing(input.spween), {text: input.spween, replace: input.part == 1n, finish: input.part == input.wings}, state, context)
57def stitching(parsed: Spween.Parsed, work: Stitching, state: State, context: Abi.Context) -> Activity<Done>:
58  match parsed:
59    case refused(r): Super.roomRefused({clause: "spween", reading: r.reason}, context)
60    case parsed(p): if Spween.joined(if work.replace then Lists.List.nil() else state.passages, p.seed.passages) != "" then Super.roomRefused({clause: "spween", reading: Spween.joined(if work.replace then Lists.List.nil() else state.passages, p.seed.passages)}, context) else stitchGuards(p.seed, Scenes.conditions(p.seed), work, state, context)
61def stitchGuards(wing: Scenes.Seed, conditions: Lists.List<String>, work: Stitching, state: State, context: Abi.Context) -> Activity<Done>:
62  match conditions:
63    case nil(_): stitchRules(wing, work, state, context)
64    case cons(c): stitchGuard(wing, c.head, c.tail, work, state, context)
65def stitchGuard(wing: Scenes.Seed, condition: String, rest: Lists.List<String>, work: Stitching, state: State, context: Abi.Context) -> Activity<Done>:
66  match world.holds({object: Plans.self(context), when: condition}):
67    case held(_): stitchGuards(wing, rest, work, state, context)
68    case refused(r): Super.roomRefused({clause: "spween", reading: "The guard `{condition}` does not read: {r.reading}"}, context)
69def stitchRules(wing: Scenes.Seed, work: Stitching, state: State, context: Abi.Context) -> Activity<Done>:
70  let all = Lists.concat(if work.replace then Lists.List.nil() else state.passages, wing.passages)
71  match world.inspect({object: Plans.self(context), source: false}):
72    case inspected(i): stitchAmend(wing, work, all, "{if work.replace then sceneLawWithout(i.law, Scenes.castsOf(state.passages)) else i.law}{Scenes.ruleText(wing.passages)}", state, context)
73    case _: Super.roomRefused({clause: "spween", reading: "The station's text is not readable here; nothing was stitched."}, context)
74# Scene rules have the names of their passage, choice and cast. Only those rule lines are removed;
75# the owner's other laws, rules and wants retain their text, wherever they stand in the law.
76def sceneLawWithout(law: String, casts: Lists.List<Scenes.Cast>) -> String:
77  let at = Text.indexOf(law, "\n")
78  let line = textTake(law, at)
79  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
80  if at == textLength(law) then kept else lawJoined(kept, sceneLawWithout(textDrop(law, at + 1n), casts))
81def lawJoined(first: String, rest: String) -> String:
82  if first == "" then rest else if rest == "" then first else "{first}\n{rest}"
83def stitchAmend(wing: Scenes.Seed, work: Stitching, all: Lists.List<Scenes.Passage>, law: String, state: State, context: Abi.Context) -> Activity<Done>:
84  match world.amend({object: Plans.self(context), law: law}):
85    case amended(_): stitchCleared(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)
86    case refused(r): Super.roomRefused({clause: r.clause, reading: "The wing's casts are rules the station's text could not take: {r.reading}"}, context)
87def stitchCleared(passages: Lists.List<Scenes.Passage>, requires: Scenes.Guard, wing: Scenes.Seed, work: Stitching, all: Lists.List<Scenes.Passage>, state: State, context: Abi.Context) -> Activity<Done>:
88  match passages:
89    case nil(_): stitchRequirementsCleared(requires, wing, work, all, state, context)
90    case cons(c): stitchPassageCleared(c.head, c.tail, requires, wing, work, all, state, context)
91def stitchPassageCleared(passage: Scenes.Passage, rest: Lists.List<Scenes.Passage>, requires: Scenes.Guard, wing: Scenes.Seed, work: Stitching, all: Lists.List<Scenes.Passage>, state: State, context: Abi.Context) -> Activity<Done>:
92  let written(_) = world.write(extend(keep(), {passages: Plans.Entries.removeItem({item: passage})}))
93  stitchCleared(rest, requires, wing, work, all, state, context)
94def stitchRequirementsCleared(requires: Scenes.Guard, wing: Scenes.Seed, work: Stitching, all: Lists.List<Scenes.Passage>, state: State, context: Abi.Context) -> Activity<Done>:
95  match requires:
96    case nil(_): stitchWrite(wing, work, all, state, context)
97    case cons(c): stitchRequirementCleared(c.head, c.tail, wing, work, all, state, context)
98def stitchRequirementCleared(clause: Scenes.Clause, rest: Scenes.Guard, wing: Scenes.Seed, work: Stitching, all: Lists.List<Scenes.Passage>, state: State, context: Abi.Context) -> Activity<Done>:
99  let written(_) = world.write(extend(keep(), {requires: Plans.Entries.removeItem({item: clause})}))
100  stitchRequirementsCleared(rest, wing, work, all, state, context)
101def stitchWrite(wing: Scenes.Seed, work: Stitching, all: Lists.List<Scenes.Passage>, state: State, context: Abi.Context) -> Activity<Done>:
102  let first = work.replace || Lists.length(state.passages) == 0n
103  let start = if first then wing.start else state.start
104  let digest = sha256Text("{if first then \"\" else sceneDigest(state)}{work.text}")
105  let written(_) = write {start: set start, cooldown: set if first then wing.cooldown else state.cooldown, marks: insert {name: "station-scene-{digest}-{natText(context.height)}", who: context.principal, handle: context.handle, at: context.height}}
106  stitchPassages(wing.passages, if first then wing.requires else Lists.List.nil(), wing, all, if work.finish then Relations.rows(state.presence) else Lists.List.nil(), start, context)
107def sceneDigest(state: State) -> String:
108  match Lists.find(Lists.reverse(Relations.order(state.marks, fn(m: Rows.Mark) -> Nat: m.at)), fn(m: Rows.Mark) -> Bool: Text.starts(m.name, "station-scene-")):
109    case some(m): textTake(textDrop(m.value.name, 14n), 64n)
110    case none(_): ""
111# One write a passage and a clause, each appended, as the room writes its variables.
112def stitchPassages(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>:
113  match passages:
114    case nil(_): stitchRequires(requires, wing, all, presence, start, context)
115    case cons(c): stitchPassage(c.head, c.tail, requires, wing, all, presence, start, context)
116def stitchPassage(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>:
117  let written(_) = world.write(extend(keep(), {passages: Plans.Entries.append({item: passage})}))
118  stitchPassages(rest, requires, wing, all, presence, start, context)
119def stitchRequires(requires: Scenes.Guard, wing: Scenes.Seed, all: Lists.List<Scenes.Passage>, presence: Lists.List<Rows.Presence>, start: String, context: Abi.Context) -> Activity<Done>:
120  match requires:
121    case nil(_): stitchPresence(presence, wing, all, start, context)
122    case cons(c): stitchRequire(c.head, c.tail, wing, all, presence, start, context)
123def stitchRequire(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>:
124  let written(_) = world.write(extend(keep(), {requires: Plans.Entries.append({item: clause})}))
125  stitchRequires(rest, wing, all, presence, start, context)
126def stitchPresence(presence: Lists.List<Rows.Presence>, wing: Scenes.Seed, all: Lists.List<Scenes.Passage>, start: String, context: Abi.Context) -> Activity<Done>:
127  match presence:
128    case nil(_): Card.tell(Done.done({}), Document.text("Stitched {natText(Lists.length(wing.passages))} passages; the scene holds {natText(Lists.length(all))}. {stitchWaiting(Spween.waiting(all))}\n"))
129    case cons(c): if Lists.any(all, fn(p: Scenes.Passage) -> Bool: p.id == c.head.at) then stitchPresence(c.tail, wing, all, start, context) else stitchMoved(c.head, c.tail, wing, all, start, context)
130def stitchMoved(me: Rows.Presence, rest: Lists.List<Rows.Presence>, wing: Scenes.Seed, all: Lists.List<Scenes.Passage>, start: String, context: Abi.Context) -> Activity<Done>:
131  let written(_) = write {presence: upsert {who: me.who, handle: me.handle, at: start, draw: me.draw}}
132  stitchPresence(rest, wing, all, start, context)
133def stitchWaiting(waiting: Lists.List<String>) -> String:
134  match waiting:
135    case nil(_): "Every choice leads to a passage."
136    case cons(_): "Still waiting for: {textJoin(waiting, \", \")}."
137def actions(state: State, context: Abi.Context) -> Lists.List<String>:
138  Lists.concat(Super.actions(state, context), if context.principal == state.owner then Text.words("vend stitch restitch") else Text.words(""))
139def entering(at: String, after: State, context: Abi.Context) -> Activity<Done>:
140  let written(_) = write {presence: insert {who: context.principal, handle: context.handle, at: at, draw: Super.turnDraw(context)}}
141  match Super.indexPresence(context):
142    case indexed(_): entryTold(at, after, context)
143def entryTold(at: String, after: State, context: Abi.Context) -> Activity<Done>:
144  match Super.lastLeft(context.principal, after):
145    case some(l): Super.away(at, after, l.value.entry, context)
146    case none(_): Super.welcomed(at, after, Document.text(""), context)
147# A visitor's leaving is kept (`left`, for the register's want and the return); an inhabitant's (`@station/regular`,
148# acting as itself) is its own hours, not a visit, and keeps none.
149def recorded(vars: Lists.List<Super.Edit>, said: String, after: State, context: Abi.Context) -> Activity<Done>:
150  if Text.starts(context.principal, "@") then Super.varied(vars, Done.left({}), said, after, context) else visited(vars, said, after, context)
151def visited(vars: Lists.List<Super.Edit>, said: String, after: State, context: Abi.Context) -> Activity<Done>:
152  let written(_) = write {left: insert {at: 0n, who: context.principal, entry: context.height}}
153  Super.varied(vars, Done.left({}), said, after, context)
154# The radio's song is the overnight DJ's (`<station>/dj`, kind/dj): the newest it played, else its four bars, read into
155# the scene as the variable `song` whenever a card is shown and never kept, so the radio passage says `{song}`.
156def seen(state: State, context: Abi.Context) -> Activity<Super.Seen>:
157  match world.viewField::<Relations.Relation<Rows.Line>>({object: {world: context.world, object: "{context.object}/dj"}, field: "lines"}):
158    case viewed(v): Super.seen(extend(state, {vars: Lists.append(state.vars, {name: "song", value: songOf(Relations.order(v.state, fn(l: Rows.Line) -> Nat: l.n))})}), context)
159    case _: Super.seen(state, context)
160def songOf(lines: Lists.List<Rows.Line>) -> String:
161  match Lists.find(Lists.reverse(lines), fn(l: Rows.Line) -> Bool: l.verb == "play"):
162    case some(l): l.value.text
163    case none(_): "the same four bars, nearly resolving"
164def awayLines(state: State, since: Nat, changes: Lists.List<World.Change>, context: Abi.Context) -> Document.Document:
165  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)}: {Super.clip(l.text)}\n")
166  Document.text("You were away a minute, or a year; the station did not count which.\n{textJoin(Lists.take(written, 3n), \"\")}\n")

set it in type, all 560 lines