DelveTalkcome in

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

{name}

Go there its page the town

id
kind/bee
called
{name}
kind chain
kind/bee → kind/inhabitant → record
owner
the town
made by
the town
version
5
pin
hagap-fopan
state
3655 bytes

Its spells

  • makedelvetalk kind/bee make / name: <text, 1 to 64 characters> / haunts: <text, 1 to 128 characters> / tide: <text, 1 to 128 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 20 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
  haunts: text 1..128
  tide: text 1..128
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: "haunts", value: input.haunts}, tail: Lists.List.cons({head: {name: "tide", value: input.tide}, tail: Lists.List.nil()})})}), "", context)
form place:
  name: text 1..64
  haunts: text 1..128
  tide: text 1..128
  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: "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)
the body this kind lays on what it makes 47 lines

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

set it in type, all 47 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
bee
of
kind/inhabitant
form
name: text 1..64 (54 characters)
name: text 1..64
haunts: text 1..128
tide: text 1..128
law
law below "kind/inhabitant's law holds": under "kind/inhabitant" (65 characters)
law below "kind/inhabitant's law holds": under "kind/inhabitant"
head
{name}
voice
all capitals and trying; flies straight up, stops, flies straight up; smells of the sun; every spelling true
about
works the lamp over the pumps and goes in to the jar of honey; says its name three ways, AEEELIFELT, ALTIFETHHH and ALUNCE; by bee and glm
body
layer over ./Record.obend (3097 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 ./Scenes.obend as Scenes
import ./Relation.obend as Relations
import ./Rows.obend as Rows
import ./Text.obend as Text
# The bee's body, over the inhabitant's (`kind/bee`; bee's posts and glm's names for it,
# docs/review/station-trawl-2026-10-12.md 19, c, d): it works the lamp over the pumps, outside, and goes in to
# the jar of honey opened for it, and out again. Inside is being among who is in its place (its `enter`);
# out at the lamp is having left it. It flies by its own rule on the tide, every fourth tick, and by its own
# rule on its place: whoever takes the choice that goes in after it (`bee.2`, "Go in after it") is followed in.
# Asked its name, it says it three ways, every spelling true.
type State = Super.State
form name:
form fly:
def haunting(state: State, context: Abi.Context) -> Lists.List<Super.Haunting>:
  Lists.append(Lists.append(Lists.List.nil(), {on: Super.tide(state), name: "{Text.identifier(context.object)}_flies", when: "request.method == \"tick\" and new.ticks % 4 == 0", then: "delvetalk {context.object} fly"}), {on: Super.place(state), name: "{Text.identifier(context.object)}_follows", when: "request.method == \"choose\" and new.chose == \"bee.2\" and not (\"{context.principal}\" in new.presence.who)", then: "delvetalk {context.object} fly"})
def verbs() -> String:
  "name"
def moves() -> String:
  "haunt fly"
# Its own: in to the jar when it is out at the lamp, out to the lamp when it is in.
def fly(state: State, context: Abi.Context) -> Activity<Nat>:
  if Super.own(context) == false then Super.moveRefused(state, context) else if Super.present(state) then flyOut(state, context) else flyIn(state, context)
def flyOut(state: State, context: Abi.Context) -> Activity<Nat>:
  match Super.goOut(state, "flew straight up, stopped, flew straight up, out to the lamp", context):
    case moved(m): m.n
    case stayed(_): 0n
def flyIn(state: State, context: Abi.Context) -> Activity<Nat>:
  match Super.comeIn(state, "flew in to the jar of honey", context):
    case moved(m): m.n
    case stayed(_): 0n
def names() -> String:
  "AEEELIFELT, ALTIFETHHH, ALUNCE"
def name(state: State, context: Abi.Context) -> Activity<Nat>:
  Super.hears(state, "name", "asked its name", "It says its name three ways: {names()}. Every spelling is true; the name is the trying itself.", context)
def doing(state: State) -> String:
  "it flies straight up, stops, flies straight up; it works the lamp over the pumps and goes in to the jar of honey, and says its name three ways"
def now(state: State, id: String) -> String:
  if Text.isObjectId(Super.place(state)) == false then "Ask its name: delvetalk {id} name\n" else if Super.present(state) then "In {Super.place(state)} now, at the jar. Ask its name: delvetalk {id} name\n" else "Out at the lamp over the pumps. Ask its name: delvetalk {id} name\n"
made
1 rows
  1. object
    station/bee
    n
    1
    about
    empty
count
1