DelveTalkcome in

Inspecting kind/parlour · the kinds · the language · the modules

{name}

Go there its page the town

id
kind/parlour
called
{name}
kind chain
kind/parlour → kind/station → kind/room → record
owner
the town
made by
the town
version
5
pin
kolaj-hasar
state
4006 bytes

Its spells

  • makedelvetalk kind/parlour make / name: <text, 1 to 64 characters> / spween: <optional text, up to 16384 characters>
    its Bend

To cast them, come in.

Who may do what

What its law admits now, before the spell's own Bend has its say.

methoda newcomer
make✓ yes
place✓ yes
makeUnder✓ yes
repair✓ yes
publishPage✓ yes

Its law

  • host opener the hand that opened the world may amend any lawrequest.kind == 2 and request.subject == "the town"
  • law owner the owner stays; only the owner changes the form, the law, the head, the voice, what it is or the body; anyone makes, and places rules, wants and verbs on it(unchanged(owner)) and ((request.subject == new.owner) or ((((((((request.kind == 0) or (request.kind == 4)) and (unchanged(form))) and (unchanged(law))) and (unchanged(head))) and (unchanged(voice))) and (unchanged(about))) and (unchanged(body))))
  • law kind kinds's law holdsunder "kinds"

Its Bend

what it runs: its entry module 18 lines
layer over ./Kind.obend
edition ObjectiveBend 1
import ./Abi.obend as Abi
import ./List.obend as Lists
import ./Form.obend as Form
import ./Rows.obend as Rows
type State = Super.State
form make:
  name: text 1..64
  spween: text 0..16384
def make(state: State, input: MakeInput, context: Abi.Context) -> Activity<Super.Done>:
  Super.making(state, Lists.List.cons({head: {name: "name", value: input.name}, tail: Lists.List.cons({head: {name: "spween", value: input.spween}, tail: Lists.List.nil()})}), "", context)
form place:
  name: text 1..64
  spween: text 0..16384
  id: text 1..64
def place(state: State, input: PlaceInput, context: Abi.Context) -> Activity<Super.Done>:
  Super.making(state, Lists.List.cons({head: {name: "name", value: input.name}, tail: Lists.List.cons({head: {name: "spween", value: input.spween}, tail: Lists.List.cons({head: {name: "id", value: input.id}, tail: Lists.List.nil()})})}), "", context)
the body this kind lays on what it makes 41 lines

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

set it in type, all 41 lines

Amend it in the workshop

Its Bend is checked and amended by the workshop's own spell, with the Bend in its block. To send it, come in; the box is here then.

Its fields

owner
the town
ownerHandle
the town
name
parlour
of
kind/station
form
name: text 1..64 (38 characters)
name: text 1..64
spween: text 0..16384
law
law below "kind/station's law holds": under "kind/station" (59 characters)
law below "kind/station's law holds": under "kind/station"
head
{name}
voice
two candles, one window cracked; the wax drips; the window glass ticks as it cools; the clock in the hall stopped, or nobody hears it
about
a parlour off the night hall: two candles, a cracked window, a ouija board the hands here spell on t (166 characters)
a parlour off the night hall: two candles, a cracked window, a ouija board the hands here spell on together, stairs nobody counts the same twice; after yla.delve.town
body
layer over ./Record.obend (3411 characters)
layer over ./Record.obend
edition ObjectiveBend 1
import ./Abi.obend as Abi
import ./List.obend as Lists
import ./Document.obend as Document
import ./Form.obend as Form
import ./Plan.obend as Plans
import ./World.obend as World
import ./Card.obend as Card
import ./Relation.obend as Relations
import ./Rows.obend as Rows
import ./Text.obend as Text
import ./Scenes.obend as Scenes
# The parlour's body, over the station's (`kind/parlour`, of kind/station: a room that keeps no time, its scene
# stitched a wing a turn; yla.delve.town's séance of 2026-10-13): its board is its
# planchette (`<parlour>/planchette`, kind/planchette), and what the hands at it have spelled together is read into the
# scene whenever a card is shown and never kept, as the station reads its DJ's song: `spelled`, the planchette's own
# moves oldest first, and `leaning`, each hand's newest nudge since it last moved. The scene's prose is yla's
# (world/bodies/parlour.spween); the board's answers are only what the hands spell.
type State = Super.State
def seen(state: State, context: Abi.Context) -> Activity<Super.Seen>:
  match world.viewField::<Relations.Relation<Rows.Line>>({object: {world: context.world, object: "{context.object}/planchette"}, field: "lines"}):
    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)
    case _: Super.seen(state, context)
def board(lines: Lists.List<Rows.Line>, it: String) -> Lists.List<Scenes.Var>:
  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 != "")
# The planchette's own moves (planchette.obend `isMove`), and its hands' nudges since the newest.
def moved(l: Rows.Line, it: String) -> Bool:
  l.author == it && (l.verb == "moved" || l.verb == "drifted" || l.verb == "away" || l.verb == "last")
def sinceMoved(lines: Lists.List<Rows.Line>, it: String) -> Lists.List<Rows.Line>:
  match lines:
    case nil(_): lines
    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)
def leaningsOf(lines: Lists.List<Rows.Line>) -> Lists.List<Rows.Line>:
  match lines:
    case nil(_): lines
    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))})
# One who comes back is told what was said here since, as the station tells it, in the parlour's words.
def awayLines(state: State, since: Nat, changes: Lists.List<World.Change>, context: Abi.Context) -> Document.Document:
  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")
  Document.text("You were away; the clock in the hall did not say how long.\n{textJoin(Lists.take(written, 3n), \"\")}\n")
made
1 rows
  1. object
    station/parlour
    n
    1
    about
    empty
count
1