Registry keys

lf-ask declares it; a widget that asks on its own needs no frame. Each ask keeps its own id, answer and completion, and where frames nest, it uses the nearest. Leaf calls the element a question unless its x-word module returns another word.

The ask'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 ask is complete ($awaits); they are separate because a partial value can exist while the ask is open, and an empty value can be a complete answer. all names the outcome one banner control can give every ask of this kind at once. Once created, an ask stays answered or withdrawn after when stops matching; an element that never matched creates none, and neither does a quoted widget (x-exhibit). A restated event asks again. While the agent owes a reply in a thread about the ask, anchored inside the widget, or inside its x-ask-context but no other ask, the agent is its next actor and the ask stays unanswered. A widget in a thread message keeps its ask after the thread closes. Asks and to-dos are separate records, and the user's On me list reads asks directly.

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 input names a $data.contracts contract and the string attribute whose authored value is the page's source id, and follows that source's current value; where an optional source attribute is absent, a widget reads null. A document binds each source to one contract, and a later document may rebind it; each document reads the value against its own contract and reports a mismatch as a source error. A module subscribes by widget and input name, never by a source name.

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.

Delivery inlines each used bundle once in the head and draws each element as soon as its source is complete, nested elements first. render(host, {tabStore, offer, offerElement}) builds the instance's real markup from authored values and tab-local state, without network or asynchronous work, and returns the structure the behavior module adopts with initialRender(host). For revisions and thread messages that arrive later, the widget loader imports the same bundle before the behavior module. Leaf keeps the original markup before drawing, so comparisons and readings of the source ignore the drawing. Requires x-upgrade: true; excludes x-prepaint.

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.

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 its controls beside its members, leaves the members where the author wrote them, and reads only their attributes; then, while a revision keeps the element's attributes and each member's tag and attributes in order, Leaf edits inside the members in place. Requires x-content: members and x-upgrade.

Delivery writes it into every occurrence as the element's first child, marked data-lf-prepaint, so the browser lays the widget out at its real size instead of reserving a computed height. The theme keeps the space but paints none of it. The module removes it in the same step that draws, so nothing moves, and draws by filling a copy of this markup, so the structure is stated only here. {"as": tag} reuses another widget's prepaint, for an element that first appears as that widget will inside it. Declare it on a widget whose drawn structure is fixed while its values come from the log; a widget whose rows depend on the log has no fixed structure to write here.

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, or the experimental indicate, to reach the named widget; each looks in the referrer's own document (its message, for a widget in a reply) before the page.

The only value is map, a contents map: where the margin has room and the pointer is precise, it shows as a spine in the left margin whose labels appear over the page. Delivery writes data-lf-resident into the served document, except in a thread message, which has no margin.

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 module may write the same attributes earlier during its own gesture (renderRetired), but code that needs the decision reads it from the widget's state, not the 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.

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. The detail field outcome is reserved for the one user verb that decides which members leave the page (x-retired-when).

inline-markdown formats its direct text nodes; markdown renders its data body as safe block Markdown. 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; the Threads panel 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 ask 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 the Threads panel 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.

Its module opens the member the runtime names (openingView) and records each member it shows (keepView). The runtime opens the member holding the element the URL fragment names, else the member this tab last showed, else the first; a reload prefers the member last shown. Before first paint Leaf marks the member it will open data-lf-opening, so the package theme can show that member alone until the module upgrades.

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 ask 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.

Leaf uses it when naming the widget in a panel row or comment anchor; without one, it calls an x-ask-context widget a question and anything else by its tag name without the prefix. 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.