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.

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

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