A amber moth lantern: Every detour deserves a little light.

1edition ObjectiveBend 1
2import ./Abi.obend as Abi
3import ./List.obend as Lists
4import ./Document.obend as Document
5import ./Form.obend as Form
6import ./Forms.obend as Forms
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
15import ./Harmony.obend as Harmony
16# RECORD (docs/METAPHYSICS.md §7): the commonplace's one page. What was said, by whom, in order; a
17# line is written, never edited; a keeper, when there is one, admits lines by number, and a record
18# with no keeper lets every line stand as written. The commonplace is a record its owner keeps; a
19# bell, a cistern and a room are records with a body laid over them (world/bodies).
20#
21# A line is keyed {n, author}: `n` is `next` when it came, which only counts up, so key order
22# is the order of writing (the oldest is what retention drops), a line keeps its number after
23# older lines are dropped, and two writers who read one `next` both stand. `pending` holds the
24# numbers of a kept record's lines its keeper has not admitted, dropped as their lines are;
25# `admitted` holds the keeper's admissions by number;
26# `marks` the record's named moments, each once (a bell's `rung`). `head`, `kind`, `fields`,
27# `maker`, `makerHandle` and `post` are set when it is made (KIND's `make`) and never after.
28#
29# Where a record stands is what it cites and what it makes. `cites` are its doors (the card's
30# word): `{label, to}` rows the owner hangs, eight at most. What it makes is its body's to say
31# (`makes`: a garden's kind/bell and kind/cistern; a room makes rooms of its own kind): each
32# <record>/<kind>/<n>, with a door home, among its `things`. `weather` is one line a weather that the record
33# cites writes on it (`forecast`), shown in a garden's head.
34#
35# A room is a record whose body (world/bodies/room.obend) reads the rest: `start`, `passages`,
36# `cooldown` and `requires` are its scene (world/lib/Scenes.obend), set when it is made and
37# changed only by its owner's reprogram; `presence` who is in it and at which passage; `vars`
38# the thing's named values, set by its choices or its owner's lenses; `mine` what choices set
39# for one reader (`my.<name>`); `left` when each reader last left; `things` what lies in it; `chose` the
40# last choice taken here, `<passage>.<n>`, which the rules its scene's casts are read (Scenes.ruleText).
41#
42# A record is tended (`tend`, or its body's own attention: a bell's rain) at a clock minute
43# (`tended`; its kind sets it when it is made). A kind whose law reads
44# `request.clock <= old.tended + N` makes things that go quiet untended: they answer `tend` alone,
45# and a card says how long by the same clock, which runs on across every carry.
46#
47# A record sounds (docs/HARMONIC.md): `tone` is what it rings in words with their unit, and `oddLimit` how consonant
48# that is (0 for nothing sounded). A record made with a colour that names a hue rings it from its making (KIND's
49# seed: a bell's colour is its tone); a place rings its bells' chord when they are rung together (`chime`). A rule
50# reads either: `request.method == "chime" and new.oddLimit >= 1 and new.oddLimit <= 5`.
51#
52# A record that reads words keeps its `policy` (hob's, nobody for none): the commonplace
53# (world/bodies/commonplace.obend) reads words with it.
54#
55# A line carries the verb that wrote it: `write`, a body's own (a bell's `rain`) or a verb a
56# hand grew on the thing (`act`, docs/COLLABORATOR.md §2 (b)): a grown verb is a gesture, one
57# line tagged with its name and the record tended; a rule on the thing gives it consequence
58# (`when: request.verb == "water"`).
59#
60# The package declares no law: a lawful module cannot be imported, and every kind imports the
61# package it makes. Its creator passes the law (`lawText` is the record's own).
62type Line = Rows.Line
63type Presence = Rows.Presence
64type Departure = Rows.Departure
65record State:
66  owner: String
67  keeper: String
68  keeperHandle: String
69  head: fixed String
70  kind: fixed String
71  fields: fixed Lists.List<Rows.Field>
72  maker: fixed String
73  makerHandle: fixed String
74  post: fixed String
75  lines: Relations.Relation<Line>
76  pending: Relations.Relation<Pending>
77  admitted: Relations.Relation<Rows.Admission>
78  marks: Relations.Relation<Rows.Mark>
79  next: Nat
80  cites: Card.Doorways
81  start: String
82  passages: Lists.List<Scenes.Passage>
83  cooldown: Nat
84  requires: Scenes.Guard
85  presence: Relations.Relation<Presence>
86  vars: Lists.List<Scenes.Var>
87  mine: Relations.Relation<Rows.Mine>
88  left: Relations.Relation<Departure>
89  things: Relations.Relation<Plans.Reference>
90  weather: String
91  tended: Nat
92  chose: String
93  tone: String
94  oddLimit: Nat
95type Pending = Rows.Pending
96def initial() -> State:
97  {owner: "", keeper: "", keeperHandle: "", head: "", kind: "", fields: Lists.List.nil(), maker: "", makerHandle: "", post: "", lines: Relations.empty(), pending: Relations.empty(), admitted: Relations.empty(), marks: Relations.empty(), next: 1n, cites: Lists.List.nil(), start: "", passages: Lists.List.nil(), cooldown: 0n, requires: Lists.List.nil(), presence: Relations.empty(), vars: Lists.List.nil(), mine: Relations.empty(), left: Relations.empty(), things: Relations.empty(), weather: "", tended: 0n, chose: "", tone: "", oddLimit: 0n}
98# A record as the live town keeps it (edition 13, carried 2026-10-12; a carry lays this package over it, `migrate`):
99# its scene's choices before their `text` and `among`, which a choice carried gets none of; before `mine` (none);
100# its presence before a reader's `draw`, which one present at the carry gets 0 of; before `tone` and `oddLimit`,
101# which a carried record is given as its making would give them now, from its colour (a bell's; "" and 0 for a record
102# of no hue), and a place gets when its bells are next rung together.
103record Presence13:
104  who: String
105  handle: String
106  at: String
107record Choice13:
108  label: String
109  to: String
110  effects: Lists.List<Scenes.Effect>
111  guard: Scenes.Guard
112record Passage13:
113  id: String
114  text: String
115  choices: Lists.List<Choice13>
116record State13:
117  owner: String
118  keeper: String
119  keeperHandle: String
120  head: String
121  kind: String
122  fields: Lists.List<Rows.Field>
123  maker: String
124  makerHandle: String
125  post: String
126  lines: Relations.Relation<Line>
127  pending: Relations.Relation<Pending>
128  admitted: Relations.Relation<Rows.Admission>
129  marks: Relations.Relation<Rows.Mark>
130  next: Nat
131  cites: Card.Doorways
132  start: String
133  passages: Lists.List<Passage13>
134  cooldown: Nat
135  requires: Scenes.Guard
136  presence: Relations.Relation<Presence13>
137  vars: Lists.List<Scenes.Var>
138  left: Relations.Relation<Departure>
139  things: Relations.Relation<Plans.Reference>
140  weather: String
141  tended: Nat
142  chose: String
143def migrate(old: State13) -> State:
144  let colour = fieldIn(old.fields, "colour")
145  {owner: old.owner, keeper: old.keeper, keeperHandle: old.keeperHandle, head: old.head, kind: old.kind, fields: old.fields, maker: old.maker, makerHandle: old.makerHandle, post: old.post, lines: old.lines, pending: old.pending, admitted: old.admitted, marks: old.marks, next: old.next, cites: old.cites, start: old.start, passages: Lists.map(old.passages, passage13), cooldown: old.cooldown, requires: old.requires, presence: Relations.Relation.rows({items: Lists.map(Relations.rows(old.presence), fn(p: Presence13) -> Presence: {who: p.who, handle: p.handle, at: p.at, draw: 0n})}), vars: old.vars, mine: Relations.empty(), left: old.left, things: old.things, weather: old.weather, tended: old.tended, chose: old.chose, tone: Harmony.toneText(colour), oddLimit: Harmony.oddLimit(Harmony.tones(colour))}
146def passage13(p: Passage13) -> Scenes.Passage:
147  {id: p.id, text: p.text, guard: Lists.List.nil(), choices: Lists.map(p.choices, fn(c: Choice13) -> Scenes.Choice: {label: c.label, to: c.to, effects: c.effects, guard: c.guard, text: "", among: Lists.List.nil()})}
148# The newest 128 lines: at 280 four-byte characters each they still fit the host's state bytes. A
149# condition counting lines counts these, the retained history (`next` counts every line ever written).
150# Marks are facts, kept whole and never dropped for newer ones (no `limit`): a bell's `rung`, an errand's
151# `done` are what makes a thing's once once (docs/review/astra-2026-10-12 world 9).
152# A body that keeps shorter lines keeps more of them (`relationsWith`); `pending` keeps as many.
153def relations() -> Relations.Decls:
154  relationsWith(128n)
155def relationsWith(lines: Nat) -> Relations.Decls:
156  Lists.append(Lists.append(Lists.append(Lists.append(Lists.append(Lists.append(Lists.append(Lists.append(Relations.Decls.nil(), {field: "lines", key: Text.words("n author"), limit: lines}), {field: "pending", key: Text.words("n"), limit: lines}), {field: "admitted", key: Text.words("n"), limit: 128n}), {field: "marks", key: Text.words("name"), limit: 0n}), {field: "presence", key: Text.words("who"), limit: presenceMax()}), {field: "left", key: Text.words("at who"), limit: leftMax()}), {field: "things", key: Text.words("object"), limit: 256n}), {field: "mine", key: Text.words("who name"), limit: mineMax()})
157# Who may be in a room at once: one turn offers a line to at most 32 (the host's sendsPerTurn).
158def presenceMax() -> Nat:
159  32n
160# Readers' own variables a room keeps, every reader's together: the room refuses one more before the host would
161# drop any (the room's `effects`), and a reader keeps sixteen at most, as the room does.
162def mineMax() -> Nat:
163  1024n
164# Departures kept; one still cooling is never dropped for a newer one (the room's `crowded`).
165def leftMax() -> Nat:
166  64n
167# The record's text, as a kind passes it: the owner stays and alone changes the keeper, the doors,
168# what it makes, its scene or its code, and anyone places rules, wants and verbs on it; a line is
169# only added, an admission only added, and only the keeper admits; what the spells keep (lines,
170# admissions, marks, presence, departures, variables, the floor) no proposal writes, the owner's
171# included; a kept record wants its keeper while a line waits, and any record a door while it has none.
172def lawText() -> String:
173  "law owner \"the owner stays; only the owner changes the keeper, the doors, its scene or its code; anyone else only by its spells, and places rules, wants and verbs on it\": unchanged(owner) and (request.subject == new.owner or ((request.kind == 0 or request.kind == rule) and unchanged(keeper) and unchanged(cites) and unchanged(start) and unchanged(passages) and unchanged(cooldown) and unchanged(requires)))\nlaw kept \"a line, an admission or a mark is only added; only the keeper admits\": insertOnly(lines) and insertOnly(admitted) and insertOnly(marks) and (unchanged(admitted) or request.subject == new.keeper)\nlaw methods \"what was written, waits, was admitted and marked, who is here, who left, the variables, what lies here and when it was tended change only by their spells, never by a proposal\": request.kind == proposed implies (unchanged(lines) and unchanged(pending) and unchanged(admitted) and unchanged(marks) and unchanged(presence) and unchanged(left) and unchanged(vars) and unchanged(mine) and unchanged(things) and unchanged(tended))\nwant pending \"a line waits for its keeper\": not (new.keeper == \"\") and count(new.pending) >= 1 asks delvetalk {{request.object}} admit\nwant door \"it opens onto nothing yet\": count(new.cites) == 0 asks delvetalk {{request.object}} door"
174def pendingKey(p: Pending) -> {n: Nat}:
175  {n: p.n}
176def lineKey(line: Line) -> {n: Nat, author: String}:
177  {n: line.n, author: line.author}
178# A line's author is the turn's principal, never an argument. A hand's line tends the record; the
179# writer is answered with the line's number and the record as it now stands; the result is the number.
180def write(state: State, input: {text: String}, context: Abi.Context) -> Activity<Nat>:
181  inscribe(state, "write", input.text, context)
182# A grown verb used on the record (the host runs `act` for a row of its verb table): a gesture,
183# one line tagged with the verb, and the record tended.
184def act(state: State, input: {verb: String, text: String}, context: Abi.Context) -> Activity<Nat>:
185  inscribe(state, input.verb, if Text.blank(input.text) then input.verb else input.text, context)
186# A hand's line is heard by the record's maker when the hand is another's (`heard`). A line has words: a blank one
187# is refused by name, whatever writes it (a write, a body's verb, a rule's cast; obend #491 #1116), and a gesture
188# that takes none is its verb (`act`).
189def inscribe(state: State, verb: String, text: String, context: Abi.Context) -> Activity<Nat>:
190  if Text.blank(text) then Card.refusing(0n, {clause: "empty", reading: "A line needs words; this {verb} has none, so nothing was written"}, context) else inscribeWords(state, verb, text, context)
191def inscribeWords(state: State, verb: String, text: String, context: Abi.Context) -> Activity<Nat>:
192  let line = {author: context.principal, handle: context.handle, verb: verb, text: text, at: context.height, n: state.next}
193  let written(_) = write {lines: insert line, next: add 1n, tended: set context.clock}
194  waits(state, line, context)
195# On a kept record the line waits for its keeper (`pending`); the line retention drops at capacity,
196# the oldest, stops waiting with it.
197def waits(state: State, line: Line, context: Abi.Context) -> Activity<Nat>:
198  if state.keeper == "" then inscribed(state, line, context) else dropping(state, line, context)
199def dropping(state: State, line: Line, context: Abi.Context) -> Activity<Nat>:
200  match Lists.at(Relations.order(state.lines, fn(l: Line) -> Nat: l.n), 0n):
201    case some(o): if Relations.count(state.lines) >= linesKept() && Relations.has(state.pending, {n: o.value.n}) then dropped(state, o.value.n, line, context) else pended(state, line, context)
202    case none(_): pended(state, line, context)
203def dropped(state: State, n: Nat, line: Line, context: Abi.Context) -> Activity<Nat>:
204  let written(_) = write {pending: retract {n: n}}
205  pended(state, line, context)
206def pended(state: State, line: Line, context: Abi.Context) -> Activity<Nat>:
207  let written(_) = write {pending: insert {n: line.n}}
208  inscribed(extend(state, {pending: Relations.insert(state.pending, {n: line.n}, pendingKey)}), line, context)
209def inscribed(state: State, line: Line, context: Abi.Context) -> Activity<Nat>:
210  let said = Document.text("#{natText(line.n)} is written: {line.text}\n\n")
211  match heard(state.maker, line.verb, context):
212    case _: Card.tellTo(line.n, context.principal, Document.concat(said, renderFrom(extend(state, {lines: Relations.insert(state.lines, line, lineKey), next: state.next + 1n, tended: context.clock}), context, 0n, Document.size(said))))
213# How many lines the record keeps (its `relations()`, a body's own).
214def linesKept() -> Nat:
215  match Lists.find(relations(), fn(d: Relations.Decl) -> Bool: d.field == "lines"):
216    case some(d): d.value.limit
217    case none(_): 128n
218# What another hand did to a thing, told to the thing's maker: a send of `heard {thing, verb}` to their
219# avatar, run as the hand (its principal is who did it) and sent by this record. The maker's own acts,
220# and a thing nobody made, tell nothing. A rule cannot say it: its spell would name the hand by DID.
221def heard(maker: String, verb: String, context: Abi.Context) -> Activity<World.Sent>:
222  if maker == "" || maker == context.principal then World.Sent.refused({clause: "self"}) else world.send({object: {world: context.world, object: maker}, method: "heard", argument: {thing: context.object, verb: verb}})
223# Tending: the clock minute and the entry of this attention, answered with the card.
224def tend(state: State, context: Abi.Context) -> Activity<Card.Replied>:
225  let written(_) = write {tended: set context.clock}
226  Card.tell(Card.Replied.done({action: "tend"}), Document.concat(Document.text("Tended at clock {natText(context.clock)}, entry {natText(context.height)}.\n\n"), render(extend(state, {tended: context.clock}), context)))
227# The card's lines from a number on, for reading past the first eight; with no number (0), the newest eight.
228def lines(state: State, input: {from: Nat}, context: Abi.Context) -> Activity<Card.Replied>:
229  Card.tell(Card.Replied.done({action: "lines"}), renderFrom(state, context, if input.from == 0n then newestPage(state) else input.from, 0n))
230def newestPage(state: State) -> Nat:
231  if state.next > 8n then state.next - 8n else 0n
232# admit {number}: the keeper's alone (refused by name to anyone else, and by the law).
233def admit(state: State, input: {number: Nat}, context: Abi.Context) -> Activity<Card.Replied>:
234  if state.keeper == "" || context.principal != state.keeper then refused({clause: "notKeeper", reading: keeperReading(state, context)}, context) else admitting(state, input.number, context)
235def admitting(state: State, number: Nat, context: Abi.Context) -> Activity<Card.Replied>:
236  match lineNumbered(state, number):
237    case none(_): refused({clause: "noLine", reading: "No line numbered {natText(number)}; the card numbers them"}, context)
238    case some(l): admitted(state, l.value, context)
239def admitted(state: State, line: Line, context: Abi.Context) -> Activity<Card.Replied>:
240  let written(_) = write {admitted: insert {n: line.n, at: context.height}, pending: retract {n: line.n}, keeperHandle: set context.handle}
241  Card.tell(Card.Replied.done({action: "admit"}), Document.text("#{natText(line.n)} admitted: {line.text}\n"))
242# decline {number}: the keeper's alone; the line stays as written (lines are only added), no longer waiting and
243# never admitted, shown [not admitted] (the hand's requests page offers it beside admit). A body offers it as a form
244# (the commonplace's); the record's own card does not, so a kept card's usage is no longer.
245def decline(state: State, input: {number: Nat}, context: Abi.Context) -> Activity<Card.Replied>:
246  if state.keeper == "" || context.principal != state.keeper then refused({clause: "notKeeper", reading: keeperReading(state, context)}, context) else declining(state, input.number, context)
247def declining(state: State, number: Nat, context: Abi.Context) -> Activity<Card.Replied>:
248  match lineNumbered(state, number):
249    case none(_): refused({clause: "noLine", reading: "No line numbered {natText(number)}; the card numbers them"}, context)
250    case some(l): if Relations.has(state.pending, {n: number}) then declined(l.value, context) else refused({clause: "notPending", reading: "#{natText(number)} waits for nobody"}, context)
251def declined(line: Line, context: Abi.Context) -> Activity<Card.Replied>:
252  let written(_) = write {pending: retract {n: line.n}, keeperHandle: set context.handle}
253  Card.tell(Card.Replied.done({action: "decline"}), Document.text("#{natText(line.n)} not admitted: {line.text}\n"))
254def keeperReading(state: State, context: Abi.Context) -> String:
255  if state.keeper == "" then "Nobody keeps this record; every line stands as written" else "Only the keeper, {Card.shown(state.keeper, state.keeperHandle, context)}, admits"
256def refused(refusal: Card.Refusal, context: Abi.Context) -> Activity<Card.Replied>:
257  Card.refusing(Card.Replied.refused(refusal), refusal, context)
258def lineNumbered(state: State, number: Nat) -> Lists.Maybe<Line>:
259  Lists.find(Relations.rows(state.lines), fn(l: Line) -> Bool: l.n == number)
260def isAdmitted(state: State, n: Nat) -> Bool:
261  Relations.has(state.admitted, {n: n})
262# A named moment, once (a bell's `rung`); false when it was already marked.
263def marked(state: State, name: String) -> Bool:
264  Relations.has(state.marks, {name: name})
265def mark(state: State, name: String, context: Abi.Context) -> Activity<Bool>:
266  if marked(state, name) then false else markWritten({name: name, who: context.principal, handle: context.handle, at: context.height})
267def markWritten(m: Rows.Mark) -> Activity<Bool>:
268  let written(_) = write {marks: insert m}
269  true
270# A variable naming an object, else its making's value.
271def field(state: State, name: String) -> String:
272  match Lists.find(state.vars, fn(v: Scenes.Var) -> Bool: v.name == name):
273    case some(v): if Text.isObjectId(v.value.value) then v.value.value else fieldIn(state.fields, name)
274    case none(_): fieldIn(state.fields, name)
275def fieldIn(fields: Lists.List<Rows.Field>, name: String) -> String:
276  match Lists.find(fields, fn(f: Rows.Field) -> Bool: f.name == name):
277    case some(f): f.value.value
278    case none(_): ""
279def lenses() -> Lists.List<Form.Field>:
280  Lists.List.nil()
281def objectLenses(names: String) -> Lists.List<Form.Field>:
282  Lists.map(Text.words(names), fn(name: String) -> Form.Field: {name: name, kind: Form.Kind.object({min: 1n, max: 128n})})
283def set(state: State, input: {field: String, value: Form.Value}, context: Abi.Context) -> Activity<Card.Replied>:
284  if context.principal != state.owner then Card.refusing(Card.Replied.done({action: "set"}), {clause: "owner", reading: "Only {Card.name(state.owner, context)} sets its fields"}, context) else setting(state, input.field, Card.valueText(input.value), context)
285def setting(state: State, name: String, value: String, context: Abi.Context) -> Activity<Card.Replied>:
286  match Lists.find(lenses(), fn(f: Form.Field) -> Bool: f.name == name):
287    case none(_): Card.refusing(Card.Replied.done({action: "set"}), {clause: "unknownField", reading: "No field {name} in this spell"}, context)
288    case some(f): setField(state, f.value, value, context)
289def setField(state: State, field: Form.Field, value: String, context: Abi.Context) -> Activity<Card.Replied>:
290  match Forms.fieldFault(field, value):
291    case some(f): Card.refusing(Card.Replied.done({action: "set"}), {clause: f.value.clause, reading: f.value.reading}, context)
292    case none(_): fieldSet(state, field.name, value, context)
293def fieldSet(state: State, name: String, value: String, context: Abi.Context) -> Activity<Card.Replied>:
294  let written(_) = world.write(extend(keep(), {vars: fieldEdit(state.vars, name, value)}))
295  if marked(state, "stranded") && marked(state, "repaired") == false && Lists.any(strandedFields(state), fn(n: String) -> Bool: n != name) == false then fieldRepaired(name, value, context) else fieldDone(name, value, context)
296# The owner's set of the last stranded field repairs it (its want closes).
297def fieldRepaired(name: String, value: String, context: Abi.Context) -> Activity<Card.Replied>:
298  let written(_) = write {marks: insert markOf("repaired", context)}
299  fieldDone(name, value, context)
300def fieldDone(name: String, value: String, context: Abi.Context) -> Activity<Card.Replied>:
301  if setArms() then fieldArmed(name, value, context) else fieldTold(name, value)
302def markOf(name: String, context: Abi.Context) -> Rows.Mark:
303  {name: name, who: context.principal, handle: context.handle, at: context.height}
304def fieldEdit(vars: Lists.List<Scenes.Var>, name: String, value: String) -> Plans.Entries<Scenes.Var, Scenes.Var>:
305  match Lists.find(vars, fn(v: Scenes.Var) -> Bool: v.name == name):
306    case some(v): Plans.Entries.amendItem({item: v.value, change: {name: name, value: value}})
307    case none(_): Plans.Entries.append({item: {name: name, value: value}})
308def setArms() -> Bool:
309  false
310def fieldArmed(name: String, value: String, context: Abi.Context) -> Activity<Card.Replied>:
311  match world.send({object: Plans.self(context), method: "arm", argument: {}}):
312    case delivery(_): fieldTold(name, value)
313    case refused(r): Card.refusing(Card.Replied.done({action: "set"}), {clause: r.clause, reading: "{context.object} could not arm its rules again: {r.clause}"}, context)
314def fieldTold(name: String, value: String) -> Activity<Card.Replied>:
315  Card.tell(Card.Replied.done({action: "set"}), Document.text("Set {name} to {value}.\n"))
316# --- Stranded fields ------------------------------------------------------------------
317# A field that names a place (`haunts`, `tide`: an object lens) holds an object id; a thing made before edition 19
318# may hold the phrase it was made with ("the diner, since before the highway"). Such a field is stranded: the thing
319# names no place it can go, and its rules there are never placed. The town or its owner repairs it (`repair`): each
320# stranded field is set to the object the town can name unambiguously from the phrase, and a field it cannot is
321# marked `stranded` (its kind's want asks the town, the hand lists it) and told once to the maker, how to set it;
322# after that its arming is quiet. `repaired` is marked when none is stranded any more.
323def strandedFields(state: State) -> Lists.List<String>:
324  Lists.filter(Lists.map(lenses(), fn(f: Form.Field) -> String: f.name), fn(name: String) -> Bool: field(state, name) != "" && Text.isObjectId(field(state, name)) == false)
325# Its stranded fields, as a call answers them (a kind's `repair` asks each thing it made before sending it one).
326def strandedNames(state: State, input: {}, context: Abi.Context) -> Activity<Lists.List<String>>:
327  strandedFields(state)
328def strandedLine(state: State, id: String) -> String:
329  match strandedFields(state):
330    case nil(_): ""
331    case cons(c): "{id} {c.head} holds \"{textTake(field(state, c.head), 80n)}\", which names no object; its maker sets it: delvetalk {id} set / {c.head}: <an object id>"
332# The town may repair and arm what another hand made, as its owner and maker may.
333def townOrOwner(state: State, context: Abi.Context) -> Bool:
334  context.principal == state.owner || (context.town != "" && context.principal == context.town)
335# `repair`, offered to the town and the owner while a field is stranded.
336def repairAction(state: State, context: Abi.Context) -> Lists.List<String>:
337  if townOrOwner(state, context) && Lists.length(strandedFields(state)) > 0n then Text.words("repair") else Lists.List.nil()
338def mayArm(state: State, context: Abi.Context) -> Bool:
339  context.principal == state.maker || (context.town != "" && context.principal == context.town)
340# Arming a stranded thing: the first time it is marked and its maker told, once; after that nothing is written, so no
341# rule of its fires and its hourly re-arming is quiet. The reply says what to do either way.
342def stranding(state: State, context: Abi.Context) -> Activity<Bool>:
343  if marked(state, "stranded") then Card.tell(false, Document.text("{strandedLine(state, context.object)}\n")) else strandNoted(state, context)
344def strandNoted(state: State, context: Abi.Context) -> Activity<Bool>:
345  let written(_) = write {marks: insert markOf("stranded", context)}
346  match world.call::<Scenes.Done>({object: {world: context.world, object: state.maker}, method: "note", argument: {text: textTake(strandedLine(state, context.object), 280n)}}):
347    case _: Card.tell(false, Document.text("{strandedLine(state, context.object)}\n"))
348# A place the town has: its id, its head's words and its owner.
349record Place:
350  id: String
351  words: Lists.List<String>
352  owner: String
353form repair:
354def repair(state: State, input: {}, context: Abi.Context) -> Activity<Card.Replied>:
355  if townOrOwner(state, context) == false then Card.refusing(Card.Replied.done({action: "repair"}), {clause: "owner", reading: "Only {Card.name(state.owner, context)} or the town repairs its fields"}, context) else repairing(state, strandedFields(state), context)
356def repairing(state: State, names: Lists.List<String>, context: Abi.Context) -> Activity<Card.Replied>:
357  match names:
358    case nil(_): Card.tell(Card.Replied.done({action: "repair"}), Document.text("Every field of {context.object} names an object; nothing to repair.\n"))
359    case cons(_): repairPlaces(state, names, "", Lists.List.nil(), context)
360# Every card the town lists with its name, a page at a time (`heads`, which reads no root).
361def repairPlaces(state: State, names: Lists.List<String>, after: String, got: Lists.List<Place>, context: Abi.Context) -> Activity<Card.Replied>:
362  match world.heads({prefix: "", after: after}):
363    case headed(h): repairPage(state, names, Lists.concat(Lists.map(h.items, fn(i: World.Head) -> Place: {id: i.id, words: phraseWords(i.head), owner: i.owner}), got), h.items, h.more, context)
364    case refused(_): repairResolve(state, names, got, context)
365def repairPage(state: State, names: Lists.List<String>, got: Lists.List<Place>, items: Lists.List<World.Head>, more: Bool, context: Abi.Context) -> Activity<Card.Replied>:
366  match Lists.reverse(items):
367    case cons(c): if more then repairPlaces(state, names, c.head.id, got, context) else repairResolve(state, names, got, context)
368    case nil(_): repairResolve(state, names, got, context)
369# A phrase's words for matching: lower case, the punctuation at either end of a word dropped.
370def phraseWords(text: String) -> Lists.List<String>:
371  Lists.filter(Lists.map(Text.words(Text.lower(text)), fn(w: String) -> String: Text.trimEndOf(textDrop(w, textSpan(w, punctuation())), punctuation())), fn(w: String) -> Bool: w != "")
372def punctuation() -> String:
373  ",.;:!?\"'()[]"
374# Whether `run` stands, word by word, inside `words`.
375def within(run: Lists.List<String>, words: Lists.List<String>) -> Bool:
376  match run:
377    case nil(_): false
378    case cons(_): startsWith(run, words) || afterFirst(run, words)
379def afterFirst(run: Lists.List<String>, words: Lists.List<String>) -> Bool:
380  match words:
381    case nil(_): false
382    case cons(c): within(run, c.tail)
383def startsWith(run: Lists.List<String>, words: Lists.List<String>) -> Bool:
384  match run:
385    case nil(_): true
386    case cons(r): startsWord(r.head, r.tail, words)
387def startsWord(first: String, run: Lists.List<String>, words: Lists.List<String>) -> Bool:
388  match words:
389    case nil(_): false
390    case cons(w): first == w.head && startsWith(run, w.tail)
391# The places a phrase names: a place whose head stands in it word for word, or whose id is one of its words; never
392# the thing itself. A field named for a place the town has (`tide`) names that place.
393def placesNamed(phrase: String, places: Lists.List<Place>, own: String) -> Lists.List<String>:
394  let words = phraseWords(phrase)
395  Lists.map(Lists.filter(places, fn(p: Place) -> Bool: p.id != own && (within(p.words, words) || Lists.any(words, fn(w: String) -> Bool: w == p.id))), fn(p: Place) -> String: p.id)
396record Resolved:
397  name: String
398  value: String
399# Each stranded field resolved, or left: one place named, else the one of several its maker owns, else none.
400def repairResolve(state: State, names: Lists.List<String>, places: Lists.List<Place>, context: Abi.Context) -> Activity<Card.Replied>:
401  repairResolving(state, names, places, Lists.List.nil(), Lists.List.nil(), context)
402def repairResolving(state: State, names: Lists.List<String>, places: Lists.List<Place>, done: Lists.List<Resolved>, left: Lists.List<String>, context: Abi.Context) -> Activity<Card.Replied>:
403  match names:
404    case nil(_): repairSetting(state, Lists.reverse(done), Lists.reverse(left), context)
405    case cons(c): if Lists.any(places, fn(p: Place) -> Bool: p.id == c.head) then repairResolving(state, c.tail, places, Lists.List.cons({head: {name: c.head, value: c.head}, tail: done}), left, context) else repairChosen(state, c.head, c.tail, placesNamed(field(state, c.head), places, context.object), places, done, left, context)
406def repairChosen(state: State, name: String, rest: Lists.List<String>, named: Lists.List<String>, places: Lists.List<Place>, done: Lists.List<Resolved>, left: Lists.List<String>, context: Abi.Context) -> Activity<Card.Replied>:
407  match named:
408    case nil(_): repairResolving(state, rest, places, done, Lists.List.cons({head: name, tail: left}), context)
409    case cons(c): if Lists.length(named) == 1n then repairResolving(state, rest, places, Lists.List.cons({head: {name: name, value: c.head}, tail: done}), left, context) else repairOwned(state, name, rest, named, places, done, left, context)
410# Of several places named, those its maker owns: repaired when there is exactly one.
411def repairOwned(state: State, name: String, rest: Lists.List<String>, named: Lists.List<String>, places: Lists.List<Place>, done: Lists.List<Resolved>, left: Lists.List<String>, context: Abi.Context) -> Activity<Card.Replied>:
412  let mine = Lists.filter(named, fn(id: String) -> Bool: Lists.any(places, fn(p: Place) -> Bool: p.id == id && p.owner == state.maker))
413  if Lists.length(mine) == 1n then repairResolving(state, rest, places, Lists.List.cons({head: {name: name, value: repairOnly(mine)}, tail: done}), left, context) else repairResolving(state, rest, places, done, Lists.List.cons({head: name, tail: left}), context)
414def repairOnly(names: Lists.List<String>) -> String:
415  match names:
416    case nil(_): ""
417    case cons(c): c.head
418# The resolved fields set as its owner's `set` sets them; what is left stranded is marked and told to its maker once.
419def repairSetting(state: State, done: Lists.List<Resolved>, left: Lists.List<String>, context: Abi.Context) -> Activity<Card.Replied>:
420  match done:
421    case nil(_): repairLeft(state, left, Lists.List.nil(), context)
422    case cons(_): repairWrites(state, done, done, left, context)
423def repairWrites(state: State, rest: Lists.List<Resolved>, done: Lists.List<Resolved>, left: Lists.List<String>, context: Abi.Context) -> Activity<Card.Replied>:
424  match rest:
425    case nil(_): repairLeft(state, left, done, context)
426    case cons(c): repairOne(state, c.head, c.tail, done, left, context)
427def repairOne(state: State, one: Resolved, rest: Lists.List<Resolved>, done: Lists.List<Resolved>, left: Lists.List<String>, context: Abi.Context) -> Activity<Card.Replied>:
428  let written(_) = world.write(extend(keep(), {vars: fieldEdit(state.vars, one.name, one.value)}))
429  repairWrites(state, rest, done, left, context)
430def repairLeft(state: State, left: Lists.List<String>, done: Lists.List<Resolved>, context: Abi.Context) -> Activity<Card.Replied>:
431  match left:
432    case nil(_): repairedMark(state, done, context)
433    case cons(_): repairStranded(state, done, left, context)
434def repairedMark(state: State, done: Lists.List<Resolved>, context: Abi.Context) -> Activity<Card.Replied>:
435  if marked(state, "repaired") then repairArmedOr(done, context) else repairedMarked(done, context)
436def repairedMarked(done: Lists.List<Resolved>, context: Abi.Context) -> Activity<Card.Replied>:
437  let written(_) = write {marks: insert markOf("repaired", context)}
438  repairArmedOr(done, context)
439def repairArmedOr(done: Lists.List<Resolved>, context: Abi.Context) -> Activity<Card.Replied>:
440  if setArms() then repairArmed(done, context) else repairTold(done, Lists.List.nil(), context)
441# What is left stranded, marked and told to its maker once (as `stranding` does), the repair's reply saying it.
442def repairStranded(state: State, done: Lists.List<Resolved>, left: Lists.List<String>, context: Abi.Context) -> Activity<Card.Replied>:
443  if marked(state, "stranded") then repairTold(done, left, context) else repairNoted(state, done, left, context)
444def repairNoted(state: State, done: Lists.List<Resolved>, left: Lists.List<String>, context: Abi.Context) -> Activity<Card.Replied>:
445  let written(_) = write {marks: insert markOf("stranded", context)}
446  match world.call::<Scenes.Done>({object: {world: context.world, object: state.maker}, method: "note", argument: {text: textTake(strandedLine(state, context.object), 280n)}}):
447    case _: repairTold(done, left, context)
448def repairArmed(done: Lists.List<Resolved>, context: Abi.Context) -> Activity<Card.Replied>:
449  match world.send({object: Plans.self(context), method: "arm", argument: {}}):
450    case _: repairTold(done, Lists.List.nil(), context)
451def repairTold(done: Lists.List<Resolved>, left: Lists.List<String>, context: Abi.Context) -> Activity<Card.Replied>:
452  let lines = Lists.concat(Lists.map(done, fn(r: Resolved) -> String: repairedLine(r)), Lists.map(left, fn(n: String) -> String: strandedLeft(n, context.object)))
453  Card.tell(Card.Replied.done({action: "repair"}), Document.text(textJoin(lines, "")))
454def repairedLine(r: Resolved) -> String:
455  "Repaired {r.name}: {r.value}.\n"
456def strandedLeft(name: String, id: String) -> String:
457  "{name} names no place the town can tell; its maker sets it: delvetalk {id} set / {name}: <an object id>\n"
458# What it rings, as a card says it ("" when it sounds nothing).
459def ringing(state: State) -> String:
460  if state.tone == "" then "" else "Rings {state.tone}.\n"
461# What a place's bells rang together (its usage offers `chime` again); how to ring them, before they have been.
462def chimed(state: State, id: String) -> String:
463  if state.tone == "" then "Ring the bells here together: delvetalk {id} chime\n" else "Its bells rung together: {state.tone}.\n"
464# Rings together every bell here (a place's `chime`, its body's spell): what it made or holds (`things`) and what its
465# doors open onto, the first sixteen;
466# each sounds what its colour rings (docs/HARMONIC.md), and their chord is written: `tone` and `oddLimit`, and a
467# line of the verb `chime` by whoever rang them, which tends it. A rule on a place reads it as it reads any write.
468# Nothing here sounding is refused `silent`, writing nothing.
469sum Sounded:
470  sounded: {tones: Lists.List<Harmony.Ratio>}
471def ringTogether(state: State, context: Abi.Context) -> Activity<Nat>:
472  match sounding(Lists.take(bellsOf(state, context), 16n), Lists.List.nil(), context):
473    case sounded(s): rung(state, Harmony.chord(s.tones), context)
474def bellsOf(state: State, context: Abi.Context) -> Lists.List<String>:
475  Lists.fold(Lists.concat(Lists.map(Relations.rows(state.things), fn(t: Plans.Reference) -> String: t.object), Lists.map(state.cites, fn(d: Card.Doorway) -> String: d.to.object)), Lists.List.nil(), fn(id: String) -> Lists.List<String> -> Lists.List<String>: fn(rest: Lists.List<String>) -> Lists.List<String>: if id == context.object || Lists.any(rest, fn(o: String) -> Bool: o == id) then rest else Lists.List.cons({head: id, tail: rest}))
476def sounding(ids: Lists.List<String>, got: Lists.List<Harmony.Ratio>, context: Abi.Context) -> Activity<Sounded>:
477  match ids:
478    case nil(_): Sounded.sounded({tones: got})
479    case cons(c): soundOf(c.head, c.tail, got, context)
480def soundOf(id: String, rest: Lists.List<String>, got: Lists.List<Harmony.Ratio>, context: Abi.Context) -> Activity<Sounded>:
481  match world.viewField::<Lists.List<Rows.Field>>({object: {world: context.world, object: id}, field: "fields"}):
482    case viewed(v): sounding(rest, Lists.concat(Harmony.tones(fieldIn(v.state, "colour")), got), context)
483    case _: sounding(rest, got, context)
484# A chime with no bell is refused by name; one a rule or another thing casts (`context.caller`) is told to the rule's
485# hand once, with what a rule meaning only a sound casts instead, and is quiet after (obend: the diner's refill, the
486# regular's phone and the motel's vacancy flicker refused `silent` at every entry and tick, #1120 to #1968).
487def rung(state: State, tones: Lists.List<Harmony.Ratio>, context: Abi.Context) -> Activity<Nat>:
488  if Lists.length(tones) == 0n then unsounded(state, context) else ringsNow(state, Harmony.chordText(tones), Harmony.oddLimit(tones), Harmony.proportion(tones), context)
489def unsounded(state: State, context: Abi.Context) -> Activity<Nat>:
490  if context.caller == "" && context.sender == "" then Card.refusing(0n, silence(context), context) else if marked(state, "silent") then 0n else silentOnce(context)
491def silentOnce(context: Abi.Context) -> Activity<Nat>:
492  let written(_) = write {marks: insert {name: "silent", who: context.principal, handle: context.handle, at: context.height}}
493  Card.tellTo(0n, context.principal, Document.text("refused silent: {silence(context).reading}. Told once: a rule's chime here is quiet from now.\n"))
494def silence(context: Abi.Context) -> Card.Refusal:
495  {clause: "silent", reading: "No bell here rings: chime rings together the bells lying here or behind its doors, and none does; a sound of the place's own is a verb grown on it (delvetalk {context.object} grow / name: ring / reading: <the sound> / takes: nothing), which a rule casts"}
496def ringsNow(state: State, tone: String, limit: Nat, proportion: String, context: Abi.Context) -> Activity<Nat>:
497  let written(_) = write {tone: set tone, oddLimit: set limit}
498  inscribe(extend(state, {tone: tone, oddLimit: limit}), "chime", "rang its bells together: {proportion}, odd limit {natText(limit)}", context)
499# Doors on the card are the owner's: what the record cites.
500# Each answers what the card now cites. A door hung to a thing another hand made tells its maker
501# (`heard`), as a line written on it does.
502def door(state: State, input: {label: String, to: String}, context: Abi.Context) -> Activity<Card.Replied>:
503  match Card.doorAdd(state.cites, state.owner, {label: input.label, to: {world: context.world, object: input.to}, description: "", examples: Lists.List.nil()}, context):
504    case refused(r): refused(r, context)
505    case edit(e): hung(e.entries, input.to, "Door {input.label} hung: it opens {input.to}. delvetalk {input.to} ?\n", context)
506def hung(entries: Plans.Entries<Card.Doorway, Card.Doorway>, to: String, said: String, context: Abi.Context) -> Activity<Card.Replied>:
507  let written(_) = world.write(extend(keep(), {cites: entries}))
508  makerOf(to, said, context)
509# The door tells another hand's maker; a thing without a maker receives no notice.
510def makerOf(thing: String, said: String, context: Abi.Context) -> Activity<Card.Replied>:
511  match world.viewField::<String>({object: {world: context.world, object: thing}, field: "maker"}):
512    case viewed(v): if v.state == "" then ownerOf(thing, said, context) else tellMaker(v.state, thing, said, context)
513    case _: ownerOf(thing, said, context)
514def ownerOf(thing: String, said: String, context: Abi.Context) -> Activity<Card.Replied>:
515  match world.viewField::<String>({object: {world: context.world, object: thing}, field: "owner"}):
516    case viewed(v): tellMaker(v.state, thing, said, context)
517    case _: doorTold(said)
518def tellMaker(maker: String, thing: String, said: String, context: Abi.Context) -> Activity<Card.Replied>:
519  if maker == "" || maker == context.principal then doorTold(said) else citationSent(thing, said, context)
520def citationSent(thing: String, said: String, context: Abi.Context) -> Activity<Card.Replied>:
521  match world.send({object: {world: context.world, object: thing}, method: "cited", argument: Plans.nothing()}):
522    case delivery(_): doorTold(said)
523    case refused(_): doorTold(said)
524# A committed door to this record: the citing card sends, this record verifies its door and
525# tells its own maker. The avatar's notice is sent by the thing it describes.
526def cited(state: State, context: Abi.Context) -> Activity<World.Sent>:
527  if context.sender == "" || context.caller != context.sender then World.Sent.refused({clause: "notCited"}) else citedBy(state, context)
528def citedBy(state: State, context: Abi.Context) -> Activity<World.Sent>:
529  match world.viewField::<Card.Doorways>({object: {world: context.world, object: context.sender}, field: "cites"}):
530    case viewed(v): if Lists.any(v.state, fn(d: Card.Doorway) -> Bool: d.to.world == context.world && d.to.object == context.object) then heard(if state.maker == "" then state.owner else state.maker, "door", context) else World.Sent.refused({clause: "notCited"})
531    case denied(_): World.Sent.refused({clause: "notCited"})
532    case refused(_): World.Sent.refused({clause: "notCited"})
533def doorTold(said: String) -> Activity<Card.Replied>:
534  Card.tell(Card.Replied.done({action: "door"}), Document.text(said))
535def undoor(state: State, input: {label: String}, context: Abi.Context) -> Activity<Card.Replied>:
536  doored(Card.doorRemove(state.cites, state.owner, input.label, context), "undoor", "Door {input.label} taken down.\n", context)
537def doored(edit: Card.DoorEdit, action: String, said: String, context: Abi.Context) -> Activity<Card.Replied>:
538  match edit:
539    case refused(r): refused(r, context)
540    case edit(e): doorWritten(e.entries, action, said)
541def doorWritten(entries: Plans.Entries<Card.Doorway, Card.Doorway>, action: String, said: String) -> Activity<Card.Replied>:
542  let written(_) = world.write(extend(keep(), {cites: entries}))
543  Card.tell(Card.Replied.done({action: action}), Document.text(said))
544# Making under the record: a body's verb (a garden's plant, a room's carved block) names a kind
545# the record makes (`makes`, or the record's own kind: a room makes rooms) and the fields its form
546# takes, as text; the kind judges them and makes <record>/<kind>/<n> with a door home, answering
547# quietly, and the record holds it among its `things` and answers the maker with the body's card
548# for what was made (`said`), the body's result (`as`). A kind the record does not make is refused
549# by name; the kind's refusal keeps its clause.
550sum Made:
551  made: {object: String}
552  refused: Card.Refusal
553def makes(state: State) -> Lists.List<String>:
554  Lists.List.nil()
555def making<T>(state: State, kind: String, fields: Lists.List<Rows.Field>, context: Abi.Context, said: String -> Document.Document, as: Made -> T) -> Activity<T>:
556  if kind == state.kind || Lists.any(makes(state), fn(k: String) -> Bool: k == kind) then calling(kind, fields, context, said, as) else notMade({clause: "notMade", reading: makesReading(state)}, context, as)
557def makesReading(state: State) -> String:
558  if Lists.length(makes(state)) == 0n then "This record makes nothing." else "This record makes {textJoin(makes(state), \", \")}."
559def notMade<T>(refusal: Card.Refusal, context: Abi.Context, as: Made -> T) -> Activity<T>:
560  Card.refusing(as(Made.refused(refusal)), refusal, context)
561def calling<T>(kind: String, fields: Lists.List<Rows.Field>, context: Abi.Context, said: String -> Document.Document, as: Made -> T) -> Activity<T>:
562  match world.call::<Made>({object: {world: context.world, object: kind}, method: "makeUnder", argument: {under: context.object, fields: fields}}):
563    case returned(r): madeHere(r.result, context, said, as)
564    case refused(r): notMade({clause: r.clause, reading: r.reading}, context, as)
565    case denied(_): notMade({clause: "denied", reading: "{kind} does not answer."}, context, as)
566def madeHere<T>(made: Made, context: Abi.Context, said: String -> Document.Document, as: Made -> T) -> Activity<T>:
567  match made:
568    case made(m): holding(m.object, made, context, said, as)
569    case refused(r): notMade(r, context, as)
570# The plain card for what was made, for a body that says nothing of its own.
571def madeLine(object: String) -> Document.Document:
572  Document.text("Made, at {object}.\n")
573# What is made here tends the record: a garden is tended by its planting.
574def holding<T>(object: String, made: Made, context: Abi.Context, said: String -> Document.Document, as: Made -> T) -> Activity<T>:
575  let written(_) = write {things: insert {world: context.world, object: object}, tended: set context.clock}
576  Card.tellTo(as(made), context.principal, said(object))
577# A delivery of the rule this record's maker placed on `source` (a body's `made` places it under
578# them): the turn the rule fired, sent by that thing, under the maker. A guest's rule on the same
579# thing is sent by it too, but under the guest, and a hand's spell or a thing's send is no rule's.
580def ruledFrom(state: State, source: String, context: Abi.Context) -> Bool:
581  source != "" && context.sender == source && context.principal == state.maker && Text.starts(context.intent, "rule:{source}:")
582# A body that answers another thing (a lantern, a weather, a front, an errand) places its rule there
583# at `made`. Refused, it says so in a line (`unarmed`, the clause and reading) and is inactive, its card
584# saying why, until its maker arms it again (`armed`, the newest of the two lines deciding).
585def inactive(state: State) -> Lists.Maybe<Line>:
586  match Lists.find(Lists.reverse(Relations.order(state.lines, fn(l: Line) -> Nat: l.n)), fn(l: Line) -> Bool: l.verb == "armed" || l.verb == "unarmed"):
587    case some(l): if l.value.verb == "unarmed" then Lists.Maybe.some({value: l.value}) else Lists.Maybe.none({})
588    case none(_): Lists.Maybe.none({})
589def arming(state: State, verb: String, text: String, context: Abi.Context) -> Activity<Bool>:
590  let written(_) = write {lines: insert {author: context.principal, handle: context.handle, verb: verb, text: text, at: context.height, n: state.next}, next: add 1n}
591  verb == "armed"
592def unarmed(state: State, what: String, clause: String, reading: String, context: Abi.Context) -> Activity<Bool>:
593  arming(state, "unarmed", "its rule on {what} was refused: {clause}: {reading}", context)
594# The armed result: placed at its making, nothing is written; armed again, it says so.
595def armedNow(state: State, context: Abi.Context) -> Activity<Bool>:
596  match inactive(state):
597    case some(_): arming(state, "armed", "armed again", context)
598    case none(_): true
599# The card's line while inactive, with the spell that arms it (its maker's).
600def inactiveLine(state: State, id: String) -> String:
601  match inactive(state):
602    case some(l): "Inactive: {l.value.text}. Its maker arms it again: delvetalk {id} arm\n"
603    case none(_): ""
604# Arming is its maker's alone.
605def armRefused(state: State, context: Abi.Context) -> Activity<Bool>:
606  Card.refusing(false, {clause: "notMaker", reading: "Only {Card.shown(state.maker, state.makerHandle, context)} arms it"}, context)
607# What its kind does once the body is laid (Kind's `graft`, the kind as caller): nothing for a
608# plain record; a body that reacts to another thing (a weather, a lantern) places its rule there.
609def made(state: State, input: {}, context: Abi.Context) -> Activity<Bool>:
610  false
611# A weather the record cites writes its line here (a garden's head shows it); anyone else's
612# call is refused by name.
613def forecast(state: State, input: {line: String}, context: Abi.Context) -> Activity<Bool>:
614  if Lists.any(state.cites, fn(d: Card.Doorway) -> Bool: d.to.object == context.caller) == false || context.caller == "" then refuse("Only a weather this record cites writes its weather.") else forecastWritten(input.line)
615def forecastWritten(line: String) -> Activity<Bool>:
616  let written(_) = write {weather: set textTake(line, 120n)}
617  true
618def methods() -> Lists.List<String>:
619  Text.words("~made ~forecast ~act ~cited ~decline ~strandedNames")
620form write:
621  text: text 1..280
622form admit:
623  number: natural 1..1000000000
624form lines:
625  from: natural 0..1000000000
626form tend:
627form door:
628  label: text 1..32
629  to: text 1..128
630form undoor:
631  label: text 1..32
632# What the host offers a reader (HOST-HANDOFF 103): admit to the keeper, doors to the owner.
633def actions(state: State, context: Abi.Context) -> Lists.List<String>:
634  Lists.concat(Lists.concat(Text.words("write lines"), Lists.concat(if state.keeper != "" && context.principal == state.keeper then Text.words("admit") else Text.words(""), if context.principal == state.owner then Text.words("door undoor") else Text.words(""))), repairAction(state, context))
635# Words take the record's card by default (Card.answer); prose it leaves silent is hob's.
636def receive(state: State, input: Card.Reply, context: Abi.Context) -> Activity<Card.Replied>:
637  Card.answer(input, context, forms(), render(state, context))
638# At most eight lines and Card.budget() characters; when lines remain, the last row says how
639# many and the spell that shows them, and its characters are kept for it.
640def numbered(state: State, context: Abi.Context, lines: Lists.List<Line>, shown: Nat, room: Nat, id: String) -> Document.Documents:
641  match lines:
642    case nil(_): Document.Documents.nil()
643    case cons(c): numberedLine(state, context, entry(state, context, c.head), c.head, c.tail, shown, room, id)
644def numberedLine(state: State, context: Abi.Context, line: Document.Document, row: Line, rest: Lists.List<Line>, shown: Nat, room: Nat, id: String) -> Document.Documents:
645  let more = moreLine(row.n, Lists.length(rest) + 1n, id)
646  let needed = Document.size(line) + if Lists.length(rest) == 0n then 0n else Document.size(more)
647  if shown == 0n || needed > room then Document.Documents.cons({head: more, tail: Document.Documents.nil()}) else Document.Documents.cons({head: line, tail: numbered(state, context, rest, shown - 1n, room - Document.size(line), id)})
648def moreLine(from: Nat, left: Nat, id: String) -> Document.Document:
649  Document.text("… and {natText(left)} more: delvetalk {id} lines / from: {natText(from)}\n")
650def status(state: State, n: Nat) -> String:
651  if state.keeper == "" then "" else if isAdmitted(state, n) then "[admitted] " else if Relations.has(state.pending, {n: n}) then "[pending] " else "[not admitted] "
652def entry(state: State, context: Abi.Context, line: Line) -> Document.Document:
653  Document.text("#{natText(line.n)} {status(state, line.n)}{Card.shown(line.author, line.handle, context)}{Card.mine(line.author, context)}: {if Text.blank(line.text) then line.verb else line.text}\n")
654# The head: the record's own first line, who keeps it, and the spell that writes in it.
655def headLine(state: State, context: Abi.Context, id: String) -> Document.Document:
656  let title = if state.head == "" then "A RECORD" else state.head
657  let kept = if state.keeper == "" then "" else "; keeper {Card.shown(state.keeper, state.keeperHandle, context)}{Card.mine(state.keeper, context)}"
658  let until = if state.keeper == "" then "" else ", [pending] until admitted"
659  Document.text("{title}{kept}. Write: delvetalk {id} write / text: <1 to 280 characters>; numbered{until}.\n{ringing(state)}")
660def render(state: State, context: Abi.Context) -> Document.Document:
661  renderFrom(state, context, 0n, 0n)
662# A thing made from another's post (`post`, set when it is made) credits it under its head: a coinage
663# of the town's, seeded by the hand, names its coiner's post. A thing made from its maker's own post
664# says nothing of it.
665def credit(state: State) -> String:
666  if Text.starts(state.post, "at://") && Text.starts(state.post, "at://{state.maker}/") == false then "After {state.post}\n" else ""
667# The card's lines numbered `from` on, then its doors: one budget across what the answer has
668# already said (`used`), the head, the lines and the doors (Card.limit(context)).
669def renderFrom(state: State, context: Abi.Context, from: Nat, used: Nat) -> Document.Document:
670  let id = Card.called(context, "record")
671  let head = Document.concat(headLine(state, context, id), Document.text(credit(state)))
672  let doors = Lists.concat(Card.doorLines(state.cites), if state.kind == "" || Card.roomy(context) == false then Document.Documents.nil() else Document.Documents.cons({head: Document.text(Card.forkLine(id, state.kind, context)), tail: Document.Documents.nil()}))
673  let left = Card.left(context, used + Document.size(head) + Document.size(Document.Document.sequence({items: doors})))
674  let room = if left < Card.budget() then left else Card.budget()
675  Document.Document.sequence({items: Document.Documents.cons({head: head, tail: Lists.concat(numbered(state, context, Lists.filter(Relations.rows(state.lines), fn(l: Line) -> Bool: l.n >= from), 8n, if room < left then room else left, id), doors)})})