Registry keys

The obligation's id is widget:<source-id> and never changes. value names the x-state verb whose state is the typed answer, and answered says when the obligation is complete ($awaits); they are separate because a partial value can exist while the obligation is open, and an empty value can be a complete answer. all names the outcome one control can give every obligation of this kind at once. Once created, an obligation stays answered or withdrawn after when stops matching; an element that never matched creates none, and neither does a widget inside an exhibit (x-exhibit). A restated event asks again. While the agent owes a reply in a thread about the obligation, anchored inside the widget, or inside the widget enclosing it but no other obligation, the agent is its next actor and the obligation stays unanswered. A widget in a thread message keeps its obligation after the thread closes. A question the user answers in words is an agent message's obligation, not a widget's (--obligation). Any widget may declare it, whether bundled, from a package or a page's own; the actions it names are how the user answers, and Leaf adds no answer of its own, such as a generic Done, to a widget or anything else On me.

start opens at the first line; end follows the newest entry while the user is at the end, and stays where the user scrolled back to otherwise. An authored element may set or override it with data-bound=start|end; delivery writes it as data-lf-bound.

Each names a $data.contracts contract and an optional source attribute for a page source id. Optional reference and output name an x-refers attribute and the producer's declared output. Markup binds the source or the relation, never both; an unbound input reads null, except that an x-content: data element's one input reads the text of its <pre>. A document binds each source to one contract; later documents may rebind it and read the value against their own contract. Optional property names the element property Leaf sets to the delivered value, or null while there is none; a module reads the input only there, never through a package-owned source name, and dispatches drawn naming that property and the value it drew once its marked records stand. Widget outputs are ephemeral browser derivations, without source revisions or run receipts.

Its leading heading gives their prompt, and going to one of them lands on it. Each obligation it frames keeps its own id, answer and completion, and where frames nest, an obligation uses the nearest. It requires an id and markup content. lf-ask declares it; a widget that asks on its own needs no frame.

A boolean also quotes them unconditionally: they take no input. {when: {attribute: [values]}} quotes them only while those authored attributes match, using the same presence and value rules as x-awaits.when; elsewhere they take input but still ask nothing. Modules check quoted(el) before enabling input.

The theme holds the box to it from first paint until the module marks the element drawn (lf-rendered). Declare it on a widget whose drawing can't be sized from its markup. A module that can draw at any height, such as a chart's, draws at this one, so nothing moves; for content with its own height, the reserved height is the author's estimate of it.

The reading is the newest 50 logged events, newest first, each with who acted, what they did, the id of the thread it was in, whether a later undo took it back, and, for a widget gesture, the words its ids had when it was made. The module reads it with readHistory.

input names the widget's x-data input, and run its required receipt attribute. When the source holds a different run, page check warns that the measurement is stale, and page state reports it. Rewriting the source counts as a new run even with the same value; age alone never makes a measurement stale.

Declare it only where an attribute is the title, as a column's or a tab's label is; a section is already titled by its heading, a disclosure by its summary, and a titled member by its leading <strong>. An attribute the element merely shows first, such as a metric's value, is not its title.

Each output names one $data.contracts contract. publishOutput publishes its complete value, or null while unavailable, for other widgets' x-data inputs. Outputs follow the publishing element's lifetime and remain browser-derived values without a server source revision or run receipt.

By default any change to the widget's markup replaces the whole widget, rebuilding whatever the user had open in it. members says the module builds beside its direct authored children, leaves them where the author wrote them or moves them all into the authored body its initial drawing builds, and reads only their attributes; those children may be native markup or declared member widgets. While a revision keeps the element's attributes and each child's tag and attributes in order, Leaf edits inside those children in place. A module that moved them into an authored body reads none of them, so there only the element's own attributes need to stay the same. Requires x-content: members or markup, and x-upgrade.

Where it names markdown, Leaf draws that text as a Markdown file, its soft line breaks read as spaces, in a .lf-markdown-body beside the <pre> before the element's module draws: the server in the first document, the browser in a revision or a message. So the element first paints at the size its module will draw that rendering, and the module replaces it when it draws.

The only role is pane: a reading region, named by its required label, whose body scrolls on its own while the workspace is full-height. A pane holds exactly one body element, optionally between a direct header and footer; a visible heading goes in the header. Validation reads this declaration, not tag names, so a package can contribute panes under its own tags.

An empty contract accepts any element id, as an option's for does. A typed contract names a shared registry map with via and an equality test with where, and page check requires a target whose tag's entry in that map passes the test, so a package can tell a goal reference from a worker reference without Leaf knowing either. With owns: true the referrer fills its target: page check requires the target in the referrer's own document, and requires each element there that the test selects to be named by exactly one referrer. A keyed contract {tag, key} names a member by an attribute instead of an id: the tag element whose key holds the value, inside the referrer's nearest owner in which key is unique (x-unique), as a playground preset's setting names a control by name. In the browser a module passes the attribute to navigateToDatum to reach the named widget; it looks in the referrer's own document (its message, for a widget in a reply) before the page.

Requires x-owners. The outcome is a value of the outcome field on the owner's one deciding verb. Leaf renders the decision itself, including its undo: it writes data-lf-state="<outcome>" on the owner and data-lf-retired on the removed members, which one theme rule hides. A widget reads the decision from its state, not these attributes. Once the log decides, page check lets a revision drop the member's ids, and page check --render reports a removed member that still shows words.

A shadow root attached without this key, as a page script's own custom element attaches one, is opaque: its own words can't be quoted, and the passage reading reads its host by its light children.

The element stands in the owner whose value its widget's answer names, or in one without value while the answer names none, or one no owner beside it holds: none is an empty pick, a member without the widget's x-awaits key (one the user added), or members naming different values. The answer names a value when the widget's x-awaits value verb records one string, or picks members whose key all name the same one. Moving the element sends that widget's own command through shownAnswer (module-reading.md), so the view keeps no fact of its own: the append door refuses a position move of the element, and page check refuses markup that places it apart from its widget's authored answer, owners without one that holds an answer naming no value, and an owner value the widget cannot answer. It keeps its authored order among its owner's members.

Without it the element fills its container, as every element does in other Layouts; an element read as lines of text keeps to the measure in its own stylesheet (max-inline-size: var(--lf-measure)). An authored element may override it with data-width=wide|available, which the theme applies without moving the prose.

A verb is the user's, sent from the page as action events, unless it declares writer: "agent"; the agent writes it with leaf page report, as report events. A user verb may create a child element (creates). An agent verb with text: true requires each report to carry a non-empty detail.text, a short note the report feed shows as written. The page marks a reported widget data-lf-reported until a version answers the report ($report). For each [widget, unit, verb] key, the latest action not taken back wins, and different verbs on one unit coexist. Leaf combines those actions with the authored values and hands the widget its complete state, keyed by verb, as this.state, which its render() reads. A past action keeps its key after the widget leaves the page. When an action makes the widget's x-awaits answered condition hold, Leaf records meaning.answer on it: the thread named by the widget's resolves attribute in the document the action came from, which the answer closes, or null. A decision whose outcome is the widget's x-withdrawn-as value also records null, and the page reads as if nothing had been proposed. A verb with decides: true selects which members leave the page (x-retired-when); its required outcome field names the choice. An outcome field on any other verb is ordinary domain data.

inline-markdown formats its direct text nodes; markdown renders its data body as safe block Markdown, read as a file, whose soft line breaks are spaces. A body record keeps the Markdown source, while passages read the visible words. Child elements stay HTML. In a generated child, the user's line breaks are hard breaks.

The box shows, as text, the threads anchored exactly to that element; Threads keeps the full view. An element inside thread markup or quoted content gets no box. On a widget that also asks (x-awaits), the box is where the user answers in words: while a thread there waits on the agent, the obligation leaves the user's On me list, but it is still unanswered and the widget's controls still work. hold labels a second send button whose comment carries holds, naming the widget. The widget is held while that thread is open; resolving the thread releases it. Removing the widget removes only the box, not its threads.

On each pass, Leaf calls the element's threadOutlets(targets, {signal, collection, onCommit}) with the targets anchored exactly to its items, in order, and the method returns for each an element to place it in (an outlet), or null. The widget reads its registration with threadSurface(element): update() says its outlets changed, and open(datum) opens Comment on one item. Leaf still owns anchors, drafts, sending, thread rendering, replies, reactions and focus, and decides placement inside each outlet. An item that isn't shown (not loaded, filtered out, collapsed or outdated) gets no outlet, and its threads stay in Threads and the margin.

page check and message markup refuse a repeat inside the same nearest owner, such as two controls of one playground sharing a name. A keyed x-refers contract names members by such an attribute.

Without this key the passage reader treats the widget as opaque, since its module may insert or replace words. The render check refuses a page where the wrapper's own words changed or a nested widget was removed or reordered.

Delivery carries the selector; the browser owns their membership and hidden attribute from first paint onward; authored hidden does not select a view. openingView returns the fragment's member, else the tab's saved member, else its supplied fallback (first member by default); reload prefers the saved member. keepView both shows a member and remembers it, or shows none when passed null without forgetting the last member. Its optional third argument keeps an outgoing member visible for an animation without selecting or saving it. A parts holder stands directly in a main with no Layout, each member holding its own Layout. module-authoring.md owns view-state behavior.

Declaring it also tells the theme the widget is a picture (painted data-lf-visual), so an lf-ask lays out options that hold one as it does options holding images. whole makes the picture one target. With {parts: ATTR} or {prefixes: [PREFIX, …]}, the module calls registerVisualParts(source, read) once, and read returns the current list of {id, element, label, surface?}; a comment on a part stores its id as anchor.visual. Under parts, ATTR names an attribute of the widget, as in <lf-diagram parts="all">: the registered parts become targets where the widget carries it, and without it the picture stays one target. Under prefixes, Leaf accepts any longer id starting with one of them, such as commit:3f2a under commit:. surface may name a descendant whose own paint, without decoration, gives the outline Leaf marks; element stays the target for hits and travel. A comment whose part is gone detaches on replay instead of widening to the whole picture. A visual that draws its parts over time also passes {reveal}: reveal(id) must synchronously show a state that holds that part, cancelling any pending change that would remove it, and Leaf calls it before going to the part from a thread or navigateToDatum. While a declared part is missing from the current state, its threads sit on the whole picture. Call the registration's update() after any change to rendering or geometry, including an attribute or style change in place. The render check validates each registered record.

It answers the obligation without closing the widget's resolves thread. A revision may also remove an unanswered proposal outright, whether or not it has retirable members; ids from earlier versions don't prevent it.

It belongs to the nearest owner x-owners names around that region, and page check refuses it anywhere else. A playground control written inside lf-playground-preview stays where it is written, beside the item it changes, instead of in the rail.

Without one, Leaf calls the widget by its tag name without the prefix. With module, the module may also describe the widget through lfSays(), where its text alone doesn't convey its structure, such as a rewrite's old and new text; otherwise Leaf reads the element's text.

Only a block widget whose x-content is markup may declare it, and markup content does not imply it: markup can itself be a control, or sit in a hidden panel.