Registry keys

The region begins with one direct heading, then carries any context and evidence the reader needs before the control; the nested widget still owns the answer and its fold or Request lifecycle. The banner, Asks tray, a/A ask walk, standing ring, and page state name the region while action eligibility, replay, and Request projection name the nested widget. An arrival focuses that widget's answering control but scrolls to the region's start. version check requires the leading heading and one non-quoted nested Ask source so the two identities cannot be ambiguous.

A local Ask always names the x-state verbs that answer it. The standing answer is identified by its owning widget and verb, so its complete durable record may fold on the widget or on a detail-named part; no parallel completion flag is needed. A roll-up owner can expose and gate on descendant Asks without entering the Asks list itself. The banner's count, the a/A ask walk that steps asks, the ? overlay's row, and conditional x-state actions are readings of one projection, so nothing names a tag and a new widget joins by declaring. Quoted material decides nothing — an exhibited Ask is a mention (x-exhibit). region says the widget supplies the answer control but not its own title: every matching local Ask must stand inside an x-ask-surface, whose direct heading owns the question's reading and arrival. A widget that also declares x-conversation puts a box under its own Ask, and a conversation standing in that box takes the Ask off the reader's list for as long as it waits on the agent — whoever opened it. That is not an answer: the widget's state is untouched, so a version still has to record what the words settled, and an action's requires reads the Ask as open. An ordinary reply or resolve hands the conversation back. A version-response conversation takes no reply; only authored state in a later version that answers an originating open Ask, or changes its declared answer when the Ask was already answered, unlocks the agent's resolve. Reader actions in the log do not substitute for that version. A widget inside a thread presents an Ask like one on the page, with one bound set by frozen thread markup: the thread's own reply box is already that seat, so only an action can answer it there. when selects Ask instances, answers names exactly the x-state verbs that settle one, rollup carries the logical OR of descendant Asks, until can require a distinct completion verb for a matching thread Ask, and all names a blanket answer offered by the banner.

Each member names a direct child widget and one-each names that child's required string-enum attribute. An instance must contain exactly one such child for every enum value, so a package can declare fixed semantic slots without teaching Leaf its tags or roles. The parent uses x-content: items, and the child names the parent in x-parent.

It projects exact-section threads textually from the whole log; Threads keeps the complete interactive view. Thread markup and quoted material take no second view. Where the widget also originates a local x-awaits Ask, the seat is where the reader deals with it in words: the Ask leaves their list while that conversation waits on the agent, rather than being counted a second time under a box they have already used. It is not an answer — the widget's own state is untouched, so its controls still work and an action's requires still reads the Ask as open. A conversation with response: {kind: version, verb: <answer>} carries that declaration on its root comment, has no inline reply control, and refuses leaf reply: the agent either incorporates it in a later version or opens a separate thread when that revision depends on the reader. To unlock resolve, authored state in the later version must answer an originating open Ask, or change the named answer's authored record when the Ask was already answered. Reader actions in the log do not substitute for that version. The named verb must be one of x-awaits' answers with an attribute or value record, so the resolve gate can compare the originating and current versions without naming a widget. A hold comment is such a conversation like any other. hold labels a stronger send route whose comment carries holds naming this widget: that route remains available after ordinary roots, the unresolved held thread is the hold, resolution releases it, and undoing resolution restores it atomically. Dropping the widget drops only the inline view.

Each input names a $data.contracts contract and the declared canonical string attribute whose authored value is this page's source id. An optional snapshot names a declared positive-decimal attribute that selects an immutable source snapshot; without it the input follows the current value. An optional source attribute leaves that input absent; watchData delivers null. Several widgets may bind the same source to the same contract. Across immutable versions and widgets frozen into threads, one source cannot mean two contracts; use a new source id for a new meaning. A module subscribes by widget and input name, never by a package-owned source name.

input names the widget's data input and at names its required date-time attribute. The authored words remain frozen with the version; when that source's stored updated instant moves past at, version check advises that the measurement is stale and page state reports the same debt. The declaration compares runs, not age: a source that never updates creates no warning.

The runtime speaks each to a reader listening (the value, or a flag attribute's own name), silently on screen and out of every selection, so a fact stated in ink is not silent to whoever cannot see it.

An empty contract accepts any element id (an option's for). A typed contract names a shared registry map with via and an equality predicate with where; version check then requires both an existing id and a target tag whose declaration in that package-owned map matches the predicate. This lets a package distinguish a goal, worker, or evidence reference without Leaf knowing those roles or tags. The runtime renders every valid value as a reference the reader can follow.

An optional update names the required non-empty string detail field that is the report's short human-readable news; naming it lets the canonical update feed expose those words without guessing from a widget, verb, or field name. The owning widget instance, unit, and facet together name one independently standing fact; verbs on the same tag and facet share their unit and record form, and an action outranks a report at that coordinate. A report moves declared state only, never the page's words, which is what keeps the passage reading untouched by it. The runtime paints a standing report live (data-lf-reported); it is provisional news, standing only until a version answers it. How a version answers a standing report is $report's.

offers maps each direct child widget tag to its required string-enum verb attribute, deriving the commands a particular holder presents; every live holder must carry at least one such direct offer and may offer each verb only once. verbs declares every command's complete detail schema. Optional bind maps required string detail fields to required immutable string attributes on this widget, so a crafted request cannot retarget the operation. ask: true makes the ready lifecycle a reader Ask: acceptance hands the turn to the host, pending and completed leave the reader's list, and failure returns it. region: true says the holder supplies the commands but not its own question title, so every instance stands inside an x-ask-surface whose leading direct heading owns the reading and arrival. A page holder has one lifecycle per revision; a holder in frozen thread markup has one for that document's whole lifetime. Pending excludes another request, failure reopens it, and success completes it. Each request is durable and not undoable because the host may already have acted. leaf receipt appends exactly one linked succeeded or failed outcome, and watchRequestLifecycle supplies the holder's server-projected request seat, exact request/receipt attempts, latest attempt, and ready/pending/completed phase to its package module. Leaf transports and validates the protocol but does not interpret verbs or execute them; package-owned guidance tells the host what each verb means, and external data carries replaceable evidence produced by it.

Requires x-parent. Every outcome named by one holder's slots belongs to the same facet, so only one settlement can stand. The layer renders the settlement whole, following the log's standing state both ways — reconciliation paints data-lf-state="<outcome>" on the holder and data-lf-retired on the slots that outcome retires, takes both off when a later widget-unit verb on that facet displaces the decision in the fold, and one theme rule hides the marked slots — so no module owes any of it, though one may paint the same sooner as its own gesture (renderRetired). The file's reading takes the fact from the log, and version check licenses dropping the slot's ids on it; version check --render reports a settled slot still showing words, or a mark the log never decided.

after goes inside the element's own content, ahead of the apparatus that ends it, so a word does not land on the far side of a control that closes the row. before goes at the element's start, ahead of chrome as well: leading chrome is not something the words stand beside, it is a module speaking for the whole element, so an element's opening words go above it; where an entry declares two at that edge they render in the order the entry lists them. The runtime writes them as selectable text the user can quote and comment on, where content: attr() would paint glyphs into no text node.

The owning widget instance, unit, and facet together name one independently standing fact: verbs on the same tag and facet share their unit and record form, competing verbs there supersede one another, and distinct facets coexist. The framework composes the last surviving action per coordinate with typed authored values and gives every widget its complete state through renderState, and one declaration drives the POST and re-vendor contract gates, version check's state gate (a version whose markup actively contradicts the fold without restated is refused; writing the folded state is honoring; re-emitting the previous version's state is blessed silence), construction-linked inspection, the runtime's reader-origin mark, and the version diff's state half. The browser uses requires for its controls and common send door; POST interprets the same prerequisite against the authoritative fold under the append lock. One detail field name is reserved: resolves names the comment thread an x-awaits answer closes. Admission records its effect in meaning.answer: a thread id closes it, null answers without closing, and an absent field means the action is not an answer. Historical settlement uses the admitted owner-unit-facet coordinate even after the widget retires; independent facets on the widget coexist. A report cannot declare resolves. Optional references names additional string or string-array detail fields carrying element identities; fold units and attribute-set or position records already declare their own references. Admission snapshots those direct identities while retraction keeps reading current containment. The facet, unit, requires, creates, and record forms are $state's.

Its module registers one adapter through registerThreadSurface; the adapter owns only outlet geometry and visibility, while Leaf owns Thread rendering, reply and reaction state, settlement, focus, receipts, and living-margin fallback. Returning an outlet claims that thread locally for the current reconciliation; unloaded, filtered, collapsed, outdated, or otherwise undisplayable datums return no outlet and remain in the global Threads index plus the ordinary fallback.

whole anchors the picture on the authored widget. For {parts: ATTR}, its module calls registerVisualParts(source, read) once; read returns the complete current {id, element, label, surface?} inventory. Core admits only ids authored in ATTR and derives token lookup and deepest-part hit testing from that inventory. surface defaults to element and may name one descendant whose native paint excludes decoration from the contour. It changes paint only: element remains the semantic hit and travel target. Marks and aim follow an SVG surface's painted geometry primitives; a surface with none, and every other element, uses the shown box. Targeting a mapped part stores its id as anchor.visual while the widget remains the semantic seat. A missing token or registration detaches on replay rather than widening to the whole picture. The registration's update() signals any rendering or geometry change, including an in-place attribute or style change. The render gate validates every record and requires each authored token to resolve.

A drawing declares no x-says: that box is laid out as a row holding what was drawn, so a word the layer writes into it would stand beside the drawing rather than over it, and the registry refuses the pair. Nothing is authored for it and no page asks: the theme grows the element out of the column into whichever margins are free. A margin holding something of the page's gives nothing where it holds it, and only there: an exhibit level with a note drops below it and then takes the whole width; one level with a suggestion's controls keeps its place and declines their side, a positioned row being nothing an exhibit can drop below; and one that nothing reaches keeps its place and grows both ways.

Almost no widget declares it, and none needs to while one tag is one kind of thing: a name away from the page is then the tag with its prefix dropped. It is wrong where a tag holds several kinds. Every shape of lf-suggestion came out as "suggestion", so a row in the Asks tray named a deletion by the words it proposed to remove and read exactly like the insertion above it. The word is asked for wherever the page names an element away from itself — a tray row, a comment's anchor label — and an element that has not upgraded yet, or answers nothing, falls back to the tag. The same declaration lets the module answer lfSays() with its own words, for a tag whose text nodes run together away from its paint (a rewrite's old and new); an element answering nothing is read as text.

An optional when narrows the instances that may admit work under their replayed attributes. Once admitted, a page-widget claim appears at the page edge through its Target Button even if a later layer changes x-work. The declaration is permission for runtime chrome, not a consequence of x-content: prose may itself be a holder gesture or sit in a hidden panel.