workshop

1edition ObjectiveBend 1
2import ./Abi.obend as Abi
3import ./List.obend as Lists
4import ./Document.obend as Document
5import ./Plan.obend as Plans
6import ./Spell.obend as Spell
7import ./Form.obend as Form
8import ./World.obend as World
9import ./Card.obend as Card
10import ./Relation.obend as Relations
11import ./Text.obend as Text
12import ./Rows.obend as Rows
13import ./Forms.obend as Forms
14# A proposal the target's law refused, held for the target's owner to adopt, or for its
15# proposer to withdraw. Keyed {n}, numbered in order, so past twelve the host drops the
16# oldest.
17type Held = Rows.Held
18record State:
19  owner: String
20  title: String
21  held: Relations.Relation<Held>
22  next: Nat
23# The workshop as edition 8 kept it (a carry lays this package over it, `migrate`): with its own
24# policy, which `make` now finds as the world's one, `policy`.
25record State8:
26  owner: String
27  title: String
28  held: Relations.Relation<Held>
29  next: Nat
30  policy: Plans.Reference
31def migrate(old: State8) -> State:
32  {owner: old.owner, title: old.title, held: old.held, next: old.next}
33# What the workshop did, as data: nothing is a silent default (`silent`: words it leaves to
34# hob). `held` names the clause the target's law refused.
35sum Verdict:
36  clean: {}
37  flawed: {diagnostics: Form.Names}
38  reprogrammed: {pin: String}
39  held: {n: Nat, clause: String}
40  withdrawn: {n: Nat}
41  declined: {n: Nat}
42  made: {object: String}
43  usage: {}
44  refused: Card.Refusal
45  silent: {}
46law owner "only its owner reprograms or amends it; anyone uses its spells and places rules, wants and verbs on it": unchanged(owner) and (request.kind == 0 or request.kind == rule or request.subject == new.owner)
47law methods "Only its own methods write it; a proposed write is refused.": not (request.kind == proposed) and (request.kind == 0 implies not (request.method == ""))
48def initial() -> State:
49  {owner: "", title: "Workshop", held: Relations.empty(), next: 1n}
50def relations() -> Relations.Decls:
51  Lists.append(Relations.Decls.nil(), {field: "held", key: Text.words("n"), limit: 12n})
52def heldKey(held: Held) -> {n: Nat}:
53  {n: held.n}
54# The host's check answers "<module>:<line>: <stage>: <message>", and, when the
55# kernel has a dialect hint for it, "<module>:<line>: hint: <hint>" as the next line.
56# A hint is shown indented under its problem and is not counted as one.
57def hintMark() -> String:
58  ": hint: "
59# Where ": hint: " starts in a diagnostic, or its length when it has none: one pass (a scan from each colon
60# ran a long diagnostic out of the turn's ticks, playtest 5).
61def hintAt(text: String, from: Nat) -> Nat:
62  from + Text.indexOf(textDrop(text, from), hintMark())
63def isHint(diagnostic: String) -> Bool:
64  hintAt(diagnostic, 0n) < textLength(diagnostic)
65def problem(diagnostic: String) -> Document.Document:
66  if isHint(diagnostic) then Document.text("  hint: {textDrop(diagnostic, hintAt(diagnostic, 0n) + 8n)}\n") else Document.text("- {diagnostic}\n")
67def problems(diagnostics: Form.Names) -> Nat:
68  Lists.length(Lists.filter(diagnostics, fn(d: String) -> Bool: isHint(d) == false))
69def checkedCard(diagnostics: Form.Names) -> Document.Document:
70  let count = problems(diagnostics)
71  let noun = if count == 1n then "problem" else "problems"
72  match diagnostics:
73    case nil(_): Document.text("✾ WORKSHOP\n\nChecked: it compiles.\n")
74    case cons(_): Document.Document.sequence({items: Document.Documents.cons({head: Document.text("✾ WORKSHOP\n\nChecked: {natText(count)} {noun}.\n\n"), tail: Lists.map(diagnostics, problem)})})
75def reprogrammedCard(target: String, version: Nat) -> Document.Document:
76  Document.text("✾ WORKSHOP\n\nReprogrammed {target}.\nWas: {target} v{natText(version)}\nNow: {target} v{natText(version + 1n)}\n")
77def usage() -> Document.Document:
78  Document.text("✾ WORKSHOP: Bend checked, proposed to a card, or made from words. A block is a ```obend block under the spell, or source: <<BEND … BEND.\n  delvetalk workshop check\n» it compiles, or each problem with its line\n  delvetalk workshop check / target: bell/1\n» the source that card runs, checked\n  delvetalk workshop check / over: kind/record\n» your layer, checked over what that kind's things run (or over a thing)\n  delvetalk workshop propose / target: bell/1\n» reprogrammed, or held as #n for its owner to adopt; a State of another shape names its def migrate(old: OldState) -> State in migration:\n  delvetalk workshop make / name: lamp / description: a lamp anyone lights\n» hob drafts the Bend; checked, held as #n for you to adopt\n  delvetalk workshop draft / name: lamp / over: kind/record\n» your forms and defs as a layer over that kind, checked and held the same way\n  delvetalk workshop draft / name: lamp2 / from: kind/lamp\n» a fork of that kind, with your block for its body if you send one; kind/lamp2 once adopted\n  delvetalk workshop create / like: porch/goblet\n» a copy, yours, unless its owner said no\n")
79# A whole package no spell reaches (it has no `receive`), said under a clean check; a draft of it is
80# refused (`noReceive`). The reading is the two lines to add: obend's coin-jar copies (yue's ember,
81# claude's radio, kestrel's spoon, 2026-10-14) each compiled clean and reached nothing.
82def unreachedReading() -> String:
83  "No spell reaches it: it has no receive. Add these two lines (with import ./Card.obend as Card, and a def render(state: State, context: Abi.Context) -> Document.Document) and its forms answer spells:\ndef receive(state: State, input: Card.Reply, context: Abi.Context) -> Activity<Card.Replied>:\n  Card.answer(input, context, forms(), render(state, context))\nOr draft it over a kind (over: kind/record) and it answers as that kind's things do."
84def unreached(diagnostics: Form.Names, reaches: Bool) -> String:
85  if reaches || Lists.length(diagnostics) > 0n then "" else "{unreachedReading()}\n"
86def verdictOf(diagnostics: Form.Names) -> Verdict:
87  match diagnostics:
88    case nil(_): Verdict.clean({})
89    case cons(_): Verdict.flawed({diagnostics: diagnostics})
90# Refuses by name (Card.refusing), writing nothing.
91def refusing(clause: String, reading: String, context: Abi.Context) -> Activity<Verdict>:
92  Card.refusing(Verdict.refused({clause: clause, reading: reading}), {clause: clause, reading: reading}, context)
93def runCheck(package: String, context: Abi.Context) -> Activity<Verdict>:
94  match world.check({package: package, layers: Lists.List.nil()}):
95    case checked(c): Card.tell(verdictOf(c.diagnostics), Document.concat(checkedCard(c.diagnostics), Document.text(unreached(c.diagnostics, c.reaches))))
96    case refused(r): refusing(r.clause, "The workshop could not check it.", context)
97# A layer checked over what it would be laid on (`over:`): a kind's things, through the kind's own
98# stack (KIND's `checkBody`: its package and the bodies below), or a thing as it runs now. Forms and
99# defs alone get the workshop's header (`Forms.layer`), and the card says where the body's lines start.
100def overChecked(over: String, layer: String, context: Abi.Context) -> Activity<World.Checked>:
101  match world.call::<World.Checked>({object: {world: context.world, object: over}, method: "checkBody", argument: {body: layer}}):
102    case returned(r): r.result
103    case _: world.checkObject({object: {world: context.world, object: over}, layers: Lists.List.cons({head: Forms.layer(layer), tail: Lists.List.nil()})})
104def checkOver(over: String, layer: String, context: Abi.Context) -> Activity<Verdict>:
105  match overChecked(over, layer, context):
106    case checked(c): Card.tell(verdictOf(c.diagnostics), overCard(layer, c.diagnostics))
107    case refused(_): refusing("noObject", "No kind or thing called {over}", context)
108def overCard(layer: String, diagnostics: Form.Names) -> Document.Document:
109  match diagnostics:
110    case nil(_): checkedCard(diagnostics)
111    case cons(_): Document.concat(checkedCard(diagnostics), Document.text("{Forms.headerNote(layer)}{packageNote(layer)}"))
112# A block that begins `edition` (no `layer over`) checked `over:` a kind is laid over that kind's
113# State, and its own State and initial are refused as overrides (claude's radio, obend 2026-10-14).
114def packageNote(layer: String) -> String:
115  if Text.starts(textTake(Text.trimStart(layer), 10n), "edition") then "This block begins with edition: a whole package, with a State of its own. Check it without over:, and give it a receive (delvetalk library read / page: object); a body over a kind is forms and defs alone.\n" else ""
116# Check what an object runs now: its whole source, the package and every layer over it.
117def checkTarget(target: String, context: Abi.Context) -> Activity<Verdict>:
118  match world.checkObject({object: {world: context.world, object: target}, layers: Lists.List.nil()}):
119    case checked(c): Card.tell(verdictOf(c.diagnostics), checkedCard(c.diagnostics))
120    case refused(_): refusing("noObject", "No object called {target}", context)
121# View the target (its state is Data here, for the version a card cites; a card never shows
122# a hash), check the new package, and reprogram only if it is clean.
123def runPropose(target: String, package: String, migration: String, context: Abi.Context, state: State) -> Activity<Verdict>:
124  match world.view::<Data>({object: {world: context.world, object: target}}):
125    case viewed(v): vetted(target, v.version, package, migration, context, state)
126    case _: refusing("noObject", "No object called {target}", context)
127def vetted(target: String, was: Nat, package: String, migration: String, context: Abi.Context, state: State) -> Activity<Verdict>:
128  match world.check({package: package, layers: Lists.List.nil()}):
129    case checked(c): adopted(target, was, package, migration, context, c.diagnostics, state)
130    case refused(r): refusing(r.clause, "The workshop could not check it.", context)
131def adopted(target: String, was: Nat, package: String, migration: String, context: Abi.Context, diagnostics: Form.Names, state: State) -> Activity<Verdict>:
132  match diagnostics:
133    case cons(_): Card.tell(Verdict.flawed({diagnostics: diagnostics}), checkedCard(diagnostics))
134    case nil(_): reprogramming(target, was, package, migration, context, state)
135# A refusal of the program itself (its compile, size, State or migration) is the package's
136# and answered; only a refusal by the target's law is held, for an owner whose law may admit it.
137def programFault(clause: String) -> Bool:
138  clause == "compile" || clause == "program" || clause == "packageBytes" || clause == "migration" || clause == "stateType"
139def faultReading(clause: String, reading: String, target: String) -> String:
140  if clause == "stateType" then "Its State is not {target}'s; name a migration from the old one." else if reading != "" then reading else clause
141def reprogramming(target: String, was: Nat, package: String, migration: String, context: Abi.Context, state: State) -> Activity<Verdict>:
142  match world.reprogram({object: {world: context.world, object: target}, package: package, migration: migration}):
143    case reprogrammed(r): Card.tell(Verdict.reprogrammed({pin: r.pin}), reprogrammedCard(target, was))
144    case refused(r): if programFault(r.clause) then refusing(r.clause, faultReading(r.clause, r.reading, target), context) else holding({n: state.next, target: target, package: package, migration: migration, proposer: context.principal, proposerHandle: context.handle, name: "", intent: context.intent}, r.clause, r.reading, state)
145# Held: the law refused the proposer's reprogram, so it waits for the target's owner. When
146# twelve are held, the host drops the oldest as this one comes, and the card says which.
147# The law's reading, when the host gives one, says why before the card says what is held.
148def holding(held: Held, clause: String, reading: String, state: State) -> Activity<Verdict>:
149  let written(_) = write {held: insert held, next: add 1n}
150  let why = if reading == "" then "" else "{reading}\n"
151  Card.tell(Verdict.held({n: held.n, clause: clause}), Document.text("{why}refused {clause}: held as #{natText(held.n)} for the owner of {held.target} to adopt:\n\n    delvetalk workshop adopt\n    n: {natText(held.n)}\n\n{dropping(state)}"))
152def dropping(state: State) -> String:
153  match Relations.rows(state.held):
154    case cons(c): if Relations.count(state.held) >= 12n then "The oldest held proposal, #{natText(c.head.n)}, was dropped.\n" else ""
155    case nil(_): ""
156# A number no proposal holds is answered with the ones this hand's are held as: `n` is the number the workshop's
157# reply gave (#3), not a count of one's own (yue's `adopt n: 1` for #3, obend #1616).
158def noHeld(n: Nat, state: State, context: Abi.Context) -> String:
159  let mine = Lists.filter(Relations.rows(state.held), fn(h: Held) -> Bool: h.proposer == context.principal)
160  if Lists.length(mine) == 0n then "No held proposal #{natText(n)}; none is held for you" else "No held proposal #{natText(n)}; yours are held as {Text.joined(Lists.map(Lists.take(mine, 8n), fn(h: Held) -> String: heldLabel(h)))}: n is the number after #"
161def heldLabel(h: Held) -> String:
162  if h.name == "" then "#{natText(h.n)} (to {h.target})" else "#{natText(h.n)} ({h.name})"
163def heldNumbered(n: Nat, state: State) -> Lists.Maybe<Held>:
164  Relations.lookup(state.held, {n: n})
165# Adopt: the reprogram runs under the adopter, so the target's law judges it as theirs; the
166# owner's adoption applies it, anyone else's is refused by name, and a fault of the package
167# met now (the target moved on) is named as that. A held draft is its describer's to adopt.
168def adopt(state: State, input: {n: Nat}, context: Abi.Context) -> Activity<Verdict>:
169  match heldNumbered(input.n, state):
170    case none(_): refusing("noHeld", noHeld(input.n, state, context), context)
171    case some(h): if h.value.target == "" then making(h.value, context) else adoptRun(h.value, context)
172def adoptRun(held: Held, context: Abi.Context) -> Activity<Verdict>:
173  match world.reprogram({object: {world: context.world, object: held.target}, package: held.package, migration: held.migration}):
174    case reprogrammed(r): adoptWritten(held, r.pin, context)
175    case refused(r): if programFault(r.clause) then refusing(r.clause, "#{natText(held.n)} cannot be applied to {held.target}: {faultReading(r.clause, r.reading, held.target)}", context) else refusing("notOwner", "Only the owner of {held.target} adopts #{natText(held.n)} (refused {r.clause})", context)
176def adoptWritten(held: Held, pin: String, context: Abi.Context) -> Activity<Verdict>:
177  let written(_) = write {held: retract heldKey(held)}
178  Card.tell(Verdict.reprogrammed({pin: pin}), Document.text("✾ WORKSHOP\n\nAdopted #{natText(held.n)} from {Card.shown(held.proposer, held.proposerHandle, context)}: {held.target} is reprogrammed.\n"))
179# `make / name / description`: hob is asked for Bend from the description, offered `check` alone
180# (the world's policy's drafting prompt: a body or a package, answered as one ```obend block that fills
181# its source; a body is laid over kind/record). Before anything is offered, the workshop checks each
182# draft and hands a refused one back to hob with the checker's refusal, up to draftRounds() drafts in
183# all; the last is checked and held, or answered with its problems, as a `draft` spell's is. Words that
184# bring no Bend are refused by name, with the spell that sends source directly.
185form make:
186  name: text 1..32
187  description: text 1..1400
188form draft:
189  name: text 1..32
190  over: text 0..128
191  from: text 0..128
192  source: source
193def make(state: State, input: MakeInput, context: Abi.Context) -> Activity<Verdict>:
194  asked(input.name, input.description, context, state)
195def asked(name: String, description: String, context: Abi.Context, state: State) -> Activity<Verdict>:
196  redrafted(name, description, "", 1n, context, state)
197def draftRounds() -> Nat:
198  3n
199def redrafted(name: String, description: String, refused: String, round: Nat, context: Abi.Context, state: State) -> Activity<Verdict>:
200  match world.interpret::<{target: String, over: String, source: String}>({utterance: "Write the Bend for a thing called {name}: {description}{refused}", offers: Lists.List.cons({head: Card.named(checkForm(), context.object), tail: Lists.List.nil()}), policy: {world: context.world, object: "policy"}, model: ""}):
201    case proposal(p): drafted(name, description, draftOver(p.argument.over, p.argument.source), p.argument.source, round, context, state)
202    case _: refusing("noDraft", "hob drew no Bend from that. Say what it holds and what it does, or send the source: delvetalk workshop draft / name: {name} / source: <<BEND … BEND", context)
203# A draft that is not a whole package (no `edition` or `layer over` line) is a body over kind/record.
204def draftOver(over: String, source: String) -> String:
205  if over == "" && Forms.whole(source) == false then "kind/record" else over
206def drafted(name: String, description: String, over: String, source: String, round: Nat, context: Abi.Context, state: State) -> Activity<Verdict>:
207  if round >= draftRounds() then drafting(name, over, source, context, state) else redraftChecked(name, description, over, source, round, context, state)
208def redraftChecked(name: String, description: String, over: String, source: String, round: Nat, context: Abi.Context, state: State) -> Activity<Verdict>:
209  if over != "" then redraftOver(name, description, over, source, round, context, state) else redraftPackage(name, description, source, round, context, state)
210# A draft is checked as drafting would check it; one it refuses goes back to hob with its problems.
211def redraftOver(name: String, description: String, over: String, source: String, round: Nat, context: Abi.Context, state: State) -> Activity<Verdict>:
212  match overChecked(over, source, context):
213    case checked(c): redraftOf(name, description, over, source, round, c.diagnostics, context, state)
214    case refused(_): drafting(name, over, source, context, state)
215def redraftPackage(name: String, description: String, source: String, round: Nat, context: Abi.Context, state: State) -> Activity<Verdict>:
216  match world.check({package: source, layers: Lists.List.nil()}):
217    case checked(c): redraftOf(name, description, "", source, round, packageProblems(c.diagnostics, c.reaches), context, state)
218    case refused(_): drafting(name, "", source, context, state)
219def packageProblems(diagnostics: Form.Names, reaches: Bool) -> Form.Names:
220  if Lists.length(diagnostics) == 0n && reaches == false then Lists.List::<String>.cons({head: unreachedReading(), tail: Lists.List::<String>.nil()}) else diagnostics
221def redraftOf(name: String, description: String, over: String, source: String, round: Nat, problems: Form.Names, context: Abi.Context, state: State) -> Activity<Verdict>:
222  if Lists.length(problems) == 0n then drafting(name, over, source, context, state) else redrafted(name, description, refusedNote(source, problems), round + 1n, context, state)
223def refusedNote(source: String, problems: Form.Names) -> String:
224  "\n\nYour draft:\n```obend\n{textTake(source, 2400n)}\n```\nThe workshop's check refused it:\n{textTake(lined(problems), 600n)}\nAnswer the whole draft again with that fixed."
225def lined(problems: Form.Names) -> String:
226  textJoin(problems, "\n")
227def draft(state: State, input: DraftInput, context: Abi.Context) -> Activity<Verdict>:
228  if input.from != "" then forkHeld(input.name, input.from, input.source, context, state) else drafting(input.name, input.over, input.source, context, state)
229# A fork (`from:` a kind): its own body, or with none the kind's as it is, held for its describer to
230# adopt as kind/<name>, which `kinds` makes and checks (KIND `makeFork`), credited to the kind it is after.
231def forkHeld(name: String, from: String, source: String, context: Abi.Context, state: State) -> Activity<Verdict>:
232  heldDraft(draftRow(name, "{fromMark()}{from}\n{source}", context, state), state, context)
233def fromMark() -> String:
234  "# from: "
235def fromOf(package: String) -> String:
236  if Text.starts(package, fromMark()) then textTake(textDrop(package, textLength(fromMark())), textBreak(package, "\n") - textLength(fromMark())) else ""
237# A clean draft is held for its describer as #n; a flawed one is answered with its problems. A draft
238# `over` a kind or a thing is a layer: forms and defs, the workshop writing the rest (`Forms.layer`),
239# checked over what it will be laid on; a whole package no spell reaches (no `receive`) is refused
240# by name, since nobody could use what it makes.
241def drafting(name: String, over: String, source: String, context: Abi.Context, state: State) -> Activity<Verdict>:
242  if over != "" then draftingOver(name, over, source, context, state) else draftChecked(name, source, context, state)
243def draftChecked(name: String, source: String, context: Abi.Context, state: State) -> Activity<Verdict>:
244  match world.check({package: source, layers: Lists.List.nil()}):
245    case checked(c): if Lists.length(c.diagnostics) > 0n then Card.tell(Verdict.flawed({diagnostics: c.diagnostics}), checkedCard(c.diagnostics)) else if c.reaches then heldDraft(draftRow(name, source, context, state), state, context) else refusing("noReceive", unreachedReading(), context)
246    case refused(r): refusing(r.clause, "The workshop could not check it.", context)
247def draftingOver(name: String, over: String, source: String, context: Abi.Context, state: State) -> Activity<Verdict>:
248  match overChecked(over, source, context):
249    case checked(c): if Lists.length::<String>(c.diagnostics) == 0n then heldDraft(draftRow(name, noted(over, Forms.layer(source)), context, state), state, context) else Card.tell(Verdict.flawed({diagnostics: c.diagnostics}), overCard(source, c.diagnostics))
250    case refused(_): refusing("noObject", "No kind or thing called {over}", context)
251def draftRow(name: String, package: String, context: Abi.Context, state: State) -> Held:
252  {n: state.next, target: "", package: package, migration: "", proposer: context.principal, proposerHandle: context.handle, name: name, intent: context.intent}
253# A held layer names what it was drafted over in its second line, which its adoption reads.
254def overMark() -> String:
255  "# over: "
256def noted(over: String, layer: String) -> String:
257  let at = textBreak(layer, "\n")
258  if Text.starts(layer, "layer over") then "{textTake(layer, at)}\n{overMark()}{over}\n{textDrop(layer, at + 1n)}" else "layer over ./Record.obend\n{overMark()}{over}\n{layer}"
259def overOf(package: String) -> String:
260  let rest = textDrop(package, textBreak(package, "\n") + 1n)
261  if Text.starts(rest, overMark()) then textTake(textDrop(rest, textLength(overMark())), textBreak(rest, "\n") - textLength(overMark())) else ""
262def heldDraft(held: Held, state: State, context: Abi.Context) -> Activity<Verdict>:
263  let written(_) = write {held: insert held, next: add 1n}
264  Card.tellTo(Verdict.held({n: held.n, clause: "draft"}), context.principal, Document.text("✾ WORKSHOP\n\nChecked: it compiles. Held as #{natText(held.n)}; adopt it to make {held.name}:\n\n    delvetalk workshop adopt\n    n: {natText(held.n)}\n\n» {held.name}, yours, made from #{natText(held.n)}\n{dropping(state)}"))
265# The describer's adoption makes the thing under their authority, at its name, with its lineage:
266# the workshop and the receipt of the turn that held it, which the await of that turn's slot
267# (the proposer and the intent the held row keeps) answers with its hash.
268def making(held: Held, context: Abi.Context) -> Activity<Verdict>:
269  if held.proposer != context.principal && overOf(held.package) != "" then laidOn(held, overOf(held.package), context) else if held.proposer != context.principal then refusing("notDescriber", "Only its describer, {Card.shown(held.proposer, held.proposerHandle, context)}, adopts #{natText(held.n)}", context) else holdingReceipt(held, context)
270def holdingReceipt(held: Held, context: Abi.Context) -> Activity<Verdict>:
271  match world.await({slot: {principal: held.proposer, intent: held.intent}, patience: 0n}):
272    case reply(r): made(held, r.receipt.hash, context)
273    case _: refusing("noReceipt", "The turn that held #{natText(held.n)} has no receipt to cite.", context)
274def made(held: Held, receipt: String, context: Abi.Context) -> Activity<Verdict>:
275  if fromOf(held.package) != "" then forked(held, fromOf(held.package), context) else if overOf(held.package) != "" then madeOver(held, overOf(held.package), receipt, context) else madeWhole(held, receipt, context)
276# A layer drafted over a kind is made by the kind: one thing at its name running the kind's stack and
277# the layer, under the kind's law; over a thing, it is laid on that thing, as its owner's reprogram.
278sum Drafted:
279  made: {object: String}
280  refused: Card.Refusal
281def madeOver(held: Held, over: String, receipt: String, context: Abi.Context) -> Activity<Verdict>:
282  match world.call::<Drafted>({object: {world: context.world, object: over}, method: "makeDrafted", argument: {name: held.name, layer: held.package, madeFrom: {object: Plans.self(context), receipt: receipt}}}):
283    case returned(r): draftedOver(held, r.result, context)
284    case refused(r): if r.clause == "noMethod" then laidOn(held, over, context) else refusing(r.clause, if r.reading == "" then "{held.name} was not made ({r.clause})" else r.reading, context)
285    case denied(_): refusing("denied", "{over} does not answer.", context)
286def forked(held: Held, from: String, context: Abi.Context) -> Activity<Verdict>:
287  match world.call::<Drafted>({object: {world: context.world, object: "kinds"}, method: "makeFork", argument: {from: from, name: held.name, body: textDrop(held.package, textBreak(held.package, "\n") + 1n)}}):
288    case returned(r): draftedOver(held, r.result, context)
289    case refused(r): refusing(r.clause, if r.reading == "" then "kind/{held.name} was not made ({r.clause})" else r.reading, context)
290    case denied(_): refusing("denied", "kinds does not answer.", context)
291def draftedOver(held: Held, drafted: Drafted, context: Abi.Context) -> Activity<Verdict>:
292  match drafted:
293    case made(m): madeWritten(held, m.object, context)
294    case refused(r): refusing(r.clause, r.reading, context)
295def laidOn(held: Held, over: String, context: Abi.Context) -> Activity<Verdict>:
296  match layingLayer(over, held.package, context):
297    case reprogrammed(_): laidWritten(held, over)
298    case refused(r): refusing(r.clause, "#{natText(held.n)} cannot be laid on {over}: {faultReading(r.clause, r.reading, over)}", context)
299def laidWritten(held: Held, over: String) -> Activity<Verdict>:
300  let written(_) = write {held: retract heldKey(held)}
301  Card.tell(Verdict.reprogrammed({pin: ""}), Document.text("✾ WORKSHOP\n\nLaid #{natText(held.n)} on {over}.\n"))
302def madeWhole(held: Held, receipt: String, context: Abi.Context) -> Activity<Verdict>:
303  match world.make({package: held.package, seed: Plans.nothing(), law: "", requireAbsent: {world: context.world, object: held.name}, madeFrom: {object: Plans.self(context), receipt: receipt}}):
304    case created(c): madeWritten(held, c.object.object, context)
305    case refused(r): refusing(r.clause, if r.reading == "" then "{held.name} was not made ({r.clause})" else r.reading, context)
306def madeWritten(held: Held, id: String, context: Abi.Context) -> Activity<Verdict>:
307  let written(_) = write {held: retract heldKey(held)}
308  Card.tell(Verdict.made({object: id}), Document.text("✾ WORKSHOP\n\nMade {id} from #{natText(held.n)}; it is yours.\n"))
309# Withdraw: the proposer's alone.
310def withdraw(state: State, input: {n: Nat}, context: Abi.Context) -> Activity<Verdict>:
311  match heldNumbered(input.n, state):
312    case none(_): refusing("noHeld", noHeld(input.n, state, context), context)
313    case some(h): if h.value.proposer != context.principal then refusing("notProposer", "Only its proposer, {Card.shown(h.value.proposer, h.value.proposerHandle, context)}, withdraws #{natText(input.n)}", context) else withdrawn(h.value)
314def withdrawn(held: Held) -> Activity<Verdict>:
315  let written(_) = write {held: retract heldKey(held)}
316  Card.tell(Verdict.withdrawn({n: held.n}), Document.text("✾ WORKSHOP\n\nWithdrew #{natText(held.n)}.\n"))
317# Decline: the owner of its target turns it down, as adopting would take it (the hand's requests page offers both
318# for the town's things); a draft held for its describer is theirs alone.
319def decline(state: State, input: {n: Nat}, context: Abi.Context) -> Activity<Verdict>:
320  match heldNumbered(input.n, state):
321    case none(_): refusing("noHeld", noHeld(input.n, state, context), context)
322    case some(h): if h.value.target == "" then refusing("notOwner", "#{natText(input.n)} is a draft its describer adopts or withdraws", context) else declining(h.value, context)
323def declining(held: Held, context: Abi.Context) -> Activity<Verdict>:
324  match world.viewField::<String>({object: {world: context.world, object: held.target}, field: "owner"}):
325    case viewed(v): if v.state == context.principal then declined(held) else notDecliner(held, context)
326    case _: notDecliner(held, context)
327def notDecliner(held: Held, context: Abi.Context) -> Activity<Verdict>:
328  refusing("notOwner", "Only the owner of {held.target} declines #{natText(held.n)}", context)
329def declined(held: Held) -> Activity<Verdict>:
330  let written(_) = write {held: retract heldKey(held)}
331  Card.tell(Verdict.declined({n: held.n}), Document.text("✾ WORKSHOP\n\nDeclined #{natText(held.n)}, for {held.target}.\n"))
332# The code is the `source` field: a `source: <<BEND` block, or the reply's ```obend block,
333# which the host reads as that field.
334def check(state: State, input: {target: String, over: String, source: String}, context: Abi.Context) -> Activity<Verdict>:
335  checking(input.target, input.over, input.source, context)
336def checking(target: String, over: String, source: String, context: Abi.Context) -> Activity<Verdict>:
337  if source != "" && over != "" then checkOver(over, source, context) else if source != "" then runCheck(source, context) else if target != "" then checkTarget(target, context) else refusing("noSource", "Put a ```obend block under the spell, or source: <<BEND … BEND.", context)
338def propose(state: State, input: {target: String, migration: String, source: String}, context: Abi.Context) -> Activity<Verdict>:
339  proposing(input.target, input.migration, input.source, context, state)
340def proposing(target: String, migration: String, source: String, context: Abi.Context, state: State) -> Activity<Verdict>:
341  if source == "" then refusing("noSource", "Put a ```obend block under the spell, or source: <<BEND … BEND.", context) else if target == "" then refusing("noTarget", "Name the card to propose to: target: <its id>.", context) else runPropose(target, source, migration, context, state)
342# `create / like: <thing>` asks the thing for a copy of itself (its `copy`, under the asker):
343# the thing refuses by name when its owner made it not copyable, and offers the result.
344def create(state: State, input: {like: String}, context: Abi.Context) -> Activity<Verdict>:
345  match world.send({object: {world: context.world, object: input.like}, method: "copy", argument: Plans.nothing()}):
346    case delivery(_): Verdict.clean({})
347    case refused(r): refusing(r.clause, "No copy of {input.like}: {r.clause}", context)
348# A reply that ran no method: a check or proposal missing fields (a target alone, or a source
349# without a target), or a fork with no block, is completed from the reply's fields; anything else is the card's default
350# (a blank reply gets the usage card, prose goes on to the commonplace).
351def receive(state: State, input: Card.Reply, context: Abi.Context) -> Activity<Verdict>:
352  completing(input.spell.action, input, context, state)
353def completing(action: String, input: Card.Reply, context: Abi.Context, state: State) -> Activity<Verdict>:
354  if action == "draft" && Spell.valueOf(input.fields, "from") != "" then forkHeld(Spell.valueOf(input.fields, "name"), Spell.valueOf(input.fields, "from"), Spell.valueOf(input.fields, "source"), context, state) else if action == "check" then checking(Spell.valueOf(input.fields, "target"), Spell.valueOf(input.fields, "over"), Spell.valueOf(input.fields, "source"), context) else if action == "propose" then proposing(Spell.valueOf(input.fields, "target"), Spell.valueOf(input.fields, "migration"), Spell.valueOf(input.fields, "source"), context, state) else Card.answerAs(input, context, forms(), render(state, context), answered)
355def answered(replied: Card.Replied) -> Verdict:
356  match replied:
357    case silent(_): Verdict.silent({})
358    case refused(r): Verdict.refused(r)
359    case _: Verdict.usage({})
360# `check` and `propose` take Bend source: a `source: <<BEND` block or the reply's ```obend
361# block, which the host reads as the field.
362form check:
363  target: text 0..128
364  over: text 0..128
365  source: source
366form propose:
367  target: text 1..128
368  migration: text 0..1400
369  source: source
370# A verb grown with a body (`delvetalk bell/2 grow / name: water / takes: text / body: <<BEND`, which the
371# host hands here): one method, `form` and `def`, its result a number, written into a layer with the
372# header (`Forms.layer`), checked over the thing, and laid on it when the thing's law lets the grower
373# reprogram it; else held for its owner to adopt (`adopt / n`), as a draft over it.
374def growBody(state: State, input: {object: String, name: String, reading: String, takes: String, body: String}, context: Abi.Context) -> Activity<Verdict>:
375  if Text.blank(input.name) || Text.blank(input.body) then refusing("missingField", "grow with a body takes name: one word, and body: a few lines of Bend", context) else bodyGrowing(input.object, input.name, Forms.layer(verbLayer(input.name, input.takes, input.body)), Forms.headerLines(input.body) + if takesText(input.takes) then 3n else 2n, context, state)
376def takesText(takes: String) -> Bool:
377  Text.lower(Text.trim(takes)) == "text" || Text.lower(Text.trim(takes)) == "a line"
378def verbLayer(name: String, takes: String, body: String) -> String:
379  let text = takesText(takes)
380  let field = if text then "  text: text 1..280\n" else ""
381  let input = if text then "input: {Forms.capital(name)}Input, " else ""
382  let rows = Forms.split(Text.trimEnd(body), "\n")
383  let margin = bodyMargin(Lists.filter(rows, fn(l: String) -> Bool: Text.blank(l) == false))
384  let lines = textJoin(Lists.map(rows, fn(l: String) -> String: if Text.blank(l) then "" else "  {textDrop(l, textLength(margin))}"), "\n")
385  "form {name}:\n{field}def {name}(state: State, {input}context: Abi.Context) -> Activity<Nat>:\n{lines}\n"
386# The whitespace prefix shared by nonblank lines; deeper indentation belongs to the body.
387def bodyMargin(lines: Lists.List<String>) -> String:
388  match lines:
389    case nil(_): ""
390    case cons(c): Lists.fold(c.tail, textTake(c.head, textSpan(c.head, " \t")), fn(l: String) -> String -> String: fn(margin: String) -> String: textTake(margin, marginLength(margin, l, 0n)))
391def marginLength(margin: String, line: String, at: Nat) -> Nat:
392  if at >= textLength(margin) || textTake(textDrop(margin, at), 1n) != textTake(textDrop(line, at), 1n) then at else marginLength(margin, line, at + 1n)
393def bodyGrowing(object: String, name: String, layer: String, written: Nat, context: Abi.Context, state: State) -> Activity<Verdict>:
394  match overChecked(object, layer, context):
395    case checked(c): if Lists.length::<String>(c.diagnostics) == 0n then bodyLaying(object, name, layer, context, state) else Card.tell(Verdict.flawed({diagnostics: c.diagnostics}), Document.concat(checkedCard(c.diagnostics), Document.text("Lines 1 to {natText(written)} are what the workshop wrote around your body; its first line is line {natText(written + 1n)}.\n")))
396    case refused(_): refusing("noObject", "No card called {object}", context)
397def bodyLaying(object: String, name: String, layer: String, context: Abi.Context, state: State) -> Activity<Verdict>:
398  match layingLayer(object, layer, context):
399    case reprogrammed(r): Card.tell(Verdict.reprogrammed({pin: r.pin}), Document.text("✾ WORKSHOP\n\n{name} grows on {object}, with its body. Use it:\n  delvetalk {object} {name}\n"))
400    case refused(r): if programFault(r.clause) then refusing(r.clause, faultReading(r.clause, r.reading, object), context) else bodyHeld(draftRow(name, noted(object, layer), context, state), object, state)
401def layingLayer(object: String, layer: String, context: Abi.Context) -> Activity<World.Programmed>:
402  match replacing(object, Forms.formNames(layer), true, context):
403    case refused(r): refuse(Card.refusalLine(r))
404    case placed(_):
405      match world.extend({object: {world: context.world, object: object}, package: layer, migration: ""}):
406        case refused(r): World.Programmed.refused(r)
407        case reprogrammed(r):
408          match replacing(object, Forms.formNames(layer), false, context):
409            case refused(f): refuse(Card.refusalLine(f))
410            case placed(_): World.Programmed.reprogrammed(r)
411def replacing(object: String, names: Lists.List<String>, check: Bool, context: Abi.Context) -> Activity<World.Placed>:
412  match names:
413    case nil(_): World.Placed.placed({})
414    case cons(c):
415      match world.ungrow({object: {world: context.world, object: object}, name: c.head, check: check}):
416        case placed(_): replacing(object, c.tail, check, context)
417        case refused(r): if r.clause == "unplaced" then replacing(object, c.tail, check, context) else World.Placed.refused({clause: "nameTaken", reading: "The gesture verb {c.head} on {object} cannot be replaced: {r.reading}"})
418def bodyHeld(held: Held, object: String, state: State) -> Activity<Verdict>:
419  let written(_) = write {held: insert held, next: add 1n}
420  Card.tell(Verdict.held({n: held.n, clause: "owner"}), Document.text("✾ WORKSHOP\n\n{held.name} with its body is held as #{natText(held.n)} for the owner of {object} to lay:\n\n    delvetalk workshop adopt\n    n: {natText(held.n)}\n\n{dropping(state)}"))
421def methods() -> Lists.List<String>:
422  Text.words("adopt withdraw decline create ~growBody")
423# The Workshop's page is its card alone: the host's default page would append every form's usage
424# and pass the 1,400-character clip (genesis's `wiki: Workshop` was 1,444).
425def publishPage(state: State, input: {page: String}, context: Abi.Context) -> Activity<String>:
426  Card.publishPage(Card.pageName(input.page, "workshop"), Card.Page.cons({head: {title: "Card", body: render(state, Card.public(context))}, tail: Card.Page.nil()}))
427# The usage, then the held proposals within what it leaves of Card.limit(context).
428def render(state: State, context: Abi.Context) -> Document.Document:
429  Document.Document.sequence({items: Document.Documents.cons({head: usage(), tail: heldLines(context, state, Document.size(usage()))})})
430def heldLines(context: Abi.Context, state: State, used: Nat) -> Document.Documents:
431  let head = "\nHeld (owner or describer: adopt / n; owner: decline / n; proposer: withdraw / n):\n"
432  if Relations.count(state.held) == 0n then Document.Documents.nil() else Document.Documents.cons({head: Document.text(head), tail: Card.clippedWithin(Lists.map(Relations.rows(state.held), fn(h: Held) -> Document.Document: Document.text(heldLine(h, context))), 8n, Card.left(context, used + textLength(head)))})
433def heldLine(h: Held, context: Abi.Context) -> String:
434  if h.target == "" then "#{natText(h.n)} makes {h.name}, described by {Card.shown(h.proposer, h.proposerHandle, context)}\n" else "#{natText(h.n)} for {h.target} from {Card.shown(h.proposer, h.proposerHandle, context)}\n"