@aceshooting/lyra-ui 13.0.1 → 14.1.0

package/llms/components/lr-map.md

@@ -22,6 +22,14 @@ plus a peer-neutral `map` getter for common imperative operations. Its runtime v
 underlying MapLibre map. The component observes its own map-container allocation and calls the
 peer's `resize()` when that allocation changes.
 
+Markers and popups use the physical top-left origin required by MapLibre's projected transforms in
+both LTR and RTL. Their text and surrounding controls retain logical direction-aware layout.
+
+Live ancestor theme or token changes resolve the choropleth's stop colors and explicit or implicit
+step base color again, as well as its opacity. These are paint-only updates on the existing fill
+layer: the map instance, source, layer and viewport are preserved. Linear, logarithmic and step
+modes use the same expression semantics at initial render and after a theme change.
+
 **Properties:**
 
 - `center: [number, number] = [0, 0]`
@@ -94,7 +102,8 @@ string; geojson: GeoJSON.FeatureCollection; field: string; stops: [number, strin
   the live host cascade before passing the expression to MapLibre's WebGL renderer.
 - `markers: LyraMapMarker[] = []` (attribute: false) — `LyraMapMarker { id?: string; lngLat:
 [number, number]; color?: string; label?: string; unsafeHtml?: string }`; an explicit `id` is
-  trimmed and must be nonempty, and the first marker for an explicit ID wins. Markers are reconciled
+  trimmed and must be nonempty, and the first successfully admitted marker for an explicit ID wins.
+  A malformed earlier row does not reserve that ID. Markers are reconciled
   by that explicit ID (falling back
   to a `lng,lat` key, disambiguated by occurrence order for duplicate-coordinate id-less markers,
   when `id` is omitted) so an unchanged marker isn't torn down and recreated on every `markers`
@@ -120,7 +129,8 @@ string; geojson: GeoJSON.FeatureCollection; field: string; stops: [number, strin
 GeoJSON.FeatureCollection; tone?: 'accent' | 'success' | 'warning' |
 'danger' | 'neutral'; color?: string; strokeColor?: string; kind?: LyraMapDataLayerKind;
 heatmap?: LyraMapHeatmapOptions; cluster?: LyraMapClusterOptions }`. `sourceId` is trimmed and must be nonempty; the first layer for a
-  `sourceId` wins and blank or later duplicate records are ignored. Each retained entry adds one
+  `sourceId` that is successfully admitted wins; blank, malformed, and later duplicate records are
+  ignored without reserving an identity for a valid later sibling. Each retained entry adds one
   GeoJSON source plus three geometry-filtered layers
   (fill, line, and circle, so a mixed `FeatureCollection` renders correctly), colored from the
   matching `--lr-color-*` token (`tone` defaults to `'accent'` → `--lr-color-brand`).
@@ -144,6 +154,10 @@ heatmap?: LyraMapHeatmapOptions; cluster?: LyraMapClusterOptions }`. `sourceId`
   its private source/layers removed, and a genuinely new `sourceId` gets new resources — nothing
   leaks on removal, style change, or disconnect.
 
+  The component snapshots the configuration it reads. It passes `choropleth.geojson` and
+  `dataLayers[].geojson` through to MapLibre; assign a new `choropleth`, `dataLayers`, or `markers`
+  value after changing configuration, because mutating an assigned value is not observed.
+
   `cluster` and `kind` (both new in 12.0.0) opt one entry out of that three-layer geometry split.
   **Both are strictly additive: an entry that sets neither renders exactly what it rendered before,
   down to the layer ids and the point layer's filter.**
@@ -216,9 +230,9 @@ expensive on an animated one. When every feature has a unique `string`/`number`
 features keep semantically unchanged geometry/bbox values, the component emits MapLibre's
 incremental `updateData()` for property changes, additions, removals, and order changes. The exact
 next order is preserved: an unchanged prefix stays in place and only the invalidated suffix is
-removed and re-added. Lyra's immutable ownership boundary detaches GeoJSON assignments, so geometry
-reference identity cannot survive between frames; a bounded, accessor-free comparison verifies the
-JSON geometry graph instead. A missing/duplicate ID, changed geometry, exceeded bound, or uncertain
+removed and re-added. Lyra snapshots control and projection data while retaining opaque GeoJSON
+identity at the MapLibre boundary; a bounded, accessor-free comparison verifies the JSON geometry
+graph instead. A missing/duplicate ID, changed geometry, exceeded bound, or uncertain
 comparison falls back to `setData()` with no change in rendered behaviour. Peers without
 `updateData()` always take the old path.
 
@@ -273,6 +287,10 @@ zoom-to-cluster handler reads. The count label is deliberately not hit-tested (i
 the circle already queried and would only make the label the topmost hit), and a `kind: 'heatmap'`
 layer is never queried at all — MapLibre returns no features for a rendered density surface
 
+The outer marker-activation detail is frozen, while an opaque marker `unsafeHtml` value remains the
+original supplied value at the MapLibre popup and marker-activation boundary. Treat it as trusted
+markup as described above.
+
 **Slots:** `legend` — custom legend content, rendered inside the legend panel's own layout so it
 stays positioned with the map instead of floating beside it. Supplying it opens the panel even
 when `legend` and `legendGradient` are both empty.

package/llms/components/lr-markdown-core.md

@@ -25,6 +25,10 @@ this component's own module never imports or calls that function at all; it only
 `loadShikiHighlighterCore(languages)`, so a consumer importing this entry point instead of
 `markdown.js` gets a build genuinely free of shiki's full language table.
 
+Removing `content` clears the document and its empty-document tab stop, including while streaming.
+The property keeps Lit's `null` readback after removal; an explicitly empty attribute remains an
+empty string. Later source text renders normally.
+
 A fenced code block whose language isn't a key in `languages` always renders the plain-text fallback
 — there is no default/full-table highlighter here to fall back to, the same default (not degraded)
 rendering path as `<lr-code-block-core>`'s identical contract. A block that _is_ highlighted follows the

package/llms/components/lr-markdown.md

@@ -24,6 +24,10 @@ instance on a page shares one load. `heading`/`code`/`blockquote`/`table`/`link`
 rendered through a `marked` renderer override that injects `part="..."` attributes directly into the
 produced HTML in a single pass (no second DOM walk after insertion).
 
+Removing `content` clears the document and its empty-document tab stop, including while streaming.
+The property keeps Lit's `null` readback after removal; an explicitly empty attribute remains an
+empty string. Later source text renders normally.
+
 If an instance disconnects and reconnects before that shared promise settles, only the current
 connection applies the result and reparses; the stale connection callback is generation-guarded.
 
@@ -74,7 +78,9 @@ uses for its own `[part="body"]`.
   to plain text if the peer is unavailable; `escape` displays raw HTML source as text while ordinary
   Markdown still renders; `trusted` renders raw HTML without sanitization and is only for trusted
   content.
-- `gfm: boolean = true` — GitHub-flavored Markdown (tables, strikethrough, autolinks, task lists)
+- `gfm: boolean = true` — GitHub-flavored Markdown (tables, strikethrough, autolinks, task lists).
+  GFM task-list checkboxes stay disabled. A task's primary inline text supplies its accessible name;
+  nested task text is excluded, and a blank task receives no generated name.
 - `linkTarget: string | null = '_blank'` (attribute `link-target`) — `target` applied to every
   rendered `<a>`, with `rel="noopener noreferrer"` always added alongside it whenever a `target` is
   emitted. `'_blank'` (the default) preserves the original output; a falsy value (`null`, or the
@@ -90,10 +96,10 @@ uses for its own `[part="body"]`.
   than overflowing past the HTML heading levels. `0` (the default) preserves the original
   `<h${token.depth}>` output
 - `streaming: boolean = false` (reflected) — marks the host `aria-busy="true"` while partial Markdown
-  is still arriving and lets consumers target `lr-markdown[streaming]`; content updates while it is
-  true are coalesced to at most one parse per animation frame, while the final `streaming=false`
-  update flushes the latest content immediately; busy state also remains true while parser
-  dependencies are loading
+  is still arriving and lets consumers target `lr-markdown[streaming]`. Both `lr-markdown` and
+  `lr-markdown-core` display accumulated plain text without parsing or highlighting while it is
+  true. Setting `streaming=false` parses and renders the latest complete content; busy state also
+  remains true while parser dependencies are loading
 - `highlightCode: boolean = true` (attribute `highlight-code`) — syntax-highlights fenced code
   blocks via the optional `shiki` peer. `true` (the default) upgrades every fenced block once the
   peer is available; set `false` to keep plain output even when `shiki` is installed. No effect
@@ -140,9 +146,10 @@ placed first and preserved inside both ceilings.
 
 **Events:**
 
-- `lr-link-click` (`detail: { href: string }`) — fired, with the click prevented,
-  when a rendered link's `href` starts with `internal-link-prefix`; ordinary external links navigate
-  normally and never fire this
+- `lr-link-click` (`detail: { href: string }`) — fired, with navigation prevented, when a rendered
+  link's `href` starts with `internal-link-prefix`; ordinary external links navigate normally and
+  never fire this. If an intercepted link overlaps a painted highlight,
+  `lr-highlight-activate` fires first for pointer and Enter activation.
 - `lr-render-error` (`detail: { error: unknown }`) — rendering fell back to plain text (see the
   fallback matrix below), or `math` is set but the `katex` peer isn't installed
 - `lr-highlight-activate` (`detail: { highlightId: string }`) — a painted `text-quote` highlight was clicked

package/llms/components/lr-media-card.md

@@ -22,6 +22,10 @@ server-side-conversion state machine) and `lr-attachment-chip` (a pre-send queue
 upload progress). This component has neither concern; it only ever shows a `src` that's already
 final.
 
+Removing `mime-type` consumes the hint as absent and restores generic file detection unless `kind`
+explicitly selects a format. Property readback stays `null`; an explicit empty hint remains empty
+and later MIME values restore detection.
+
 **Properties:**
 
 - `src: string = ''` — the media URL. Always re-validated against a safe-scheme allowlist before
@@ -38,8 +42,7 @@ final.
   carve-out: an empty `alt` there still falls through to `filename`/the generic description, because
   an empty accessible name would leave an interactive player unnamed rather than mark it decorative.
 - `accessibleLabel: string | null = null` (attribute `aria-label`) — a declarative attribute names
-  the host as a whole while its nested button/link keeps a purpose-specific localized action name. A
-  property-only assignment can override the nested action when no host label is present. An explicit
+  the host as a whole while its nested button/link keeps a purpose-specific localized action name. A property-only assignment names the nested action and updates reactively when no host label is present, without creating a host attribute. An explicit
   empty string behaves like the unset `null` default — both fall through to the generated
   purpose-specific name. Image alt text and the native video's own purpose label remain independent;
   an explicitly empty host still leaves every interactive descendant named.
@@ -151,12 +154,6 @@ the video's own native controls bubble up and spuriously fire `lr-media-open`.
 
 **Known gotchas:**
 
-- Calling the real `.click()` (or dispatching a `click`/`MouseEvent`) on the file-chip's `<a href>`
-  in a test genuinely triggers real browser navigation — always `preventDefault()` on a `click`
-  listener registered before triggering it, the same precaution `lr-document-preview`'s own
-  download-link tests already take. A synthetic `dispatchEvent(new MouseEvent('click', {cancelable:
-true}))` still invokes the anchor's native activation behavior if nothing calls
-  `preventDefault()` during dispatch — it is not a safe no-op.
 - `kind` only reflects to the host attribute when explicitly set — CSS keying off the
   auto-detected resolved kind should target the rendered `[part]`/element (e.g. `video[part="media"]`),
   not `:host([kind=...])`, since the latter won't see an auto-detected kind.

package/llms/components/lr-mention-popover.md

@@ -18,13 +18,19 @@
 
 A caret-anchored, keyboard-navigable popover for `@`-mention and `/`-slash-command autocomplete
 inside a plain-text `<textarea>`/`<input>` the host owns. First-party invention (no Web Awesome
-equivalent). While open with a text-control `anchor`, the component atomically projects
-`role="combobox"` (unless the author supplied a role), `aria-expanded`, `aria-haspopup`, a
-resolvable controls element, and the active descendant. On platforms accepting cross-root ARIA
-element reflection, the host's own input keeps focus. Where the active-option reference is
-rejected, `focusActiveOption()` moves real focus into this component's shadow listbox so the focus
-owner and option share one tree scope. Every author ARIA value is restored on close, anchor
-replacement, disconnect, or adoption; a cross-root string IDREF is never left behind.
+equivalent). A textarea keeps its native textbox semantics while open and, after a consumed
+navigation key, `focusActiveOption()` moves real focus to the active option in the shadow listbox.
+A single-line text input retains its active-descendant element-reference route; only that route
+uses `syncActiveDescendant()`, which returns `false` for a textarea.
+Textarea ARIA/AOM values are restored on close, anchor replacement, disconnect, or adoption; a
+cross-root string IDREF is never left behind. Later localized result-count and active-position
+changes are announced once through the shared polite region; opening markup and unchanged state are
+silent.
+
+Forward native input keydown events to `handleKeyDown()` as usual. Events with `isComposing` or
+legacy `keyCode === 229` return false without preventing default, moving the active suggestion,
+selecting, or closing the popover. Removing `query` uses the unfiltered empty-query behavior while
+preserving null readback; an explicitly empty query remains empty.
 
 **Properties:**
 
@@ -66,9 +72,10 @@ replacement, disconnect, or adoption; a cross-root string IDREF is never left be
   `preventDefault()` when `filteredItems` is empty, letting the keystroke fall through to the
   host's own control unchanged. `Escape` closes with no selection. Returns `true` whenever the key
   was intercepted and `false` for keys the method does not recognize.
-- `syncActiveDescendant(control: HTMLElement): boolean` — clears any string
-  `aria-activedescendant`, then applies `ariaActiveDescendantElement` when the platform accepts the
-  cross-root reference. Returns whether that reference was accepted.
+- `syncActiveDescendant(control: HTMLElement): boolean` — applies
+  `ariaActiveDescendantElement` only for a retained single-line input route. For a textarea it
+  returns `false` without mutating `aria-activedescendant`; the managed textarea session clears that
+  value separately.
 - `focusActiveOption(options?: LyraMentionFocusOptions): Promise<boolean>` — same-tree fallback
   after a consumed navigation key when `syncActiveDescendant()` returns `false`. Focuses the active
   option, lets the popover handle subsequent navigation, and restores focus to `anchor` when the

package/llms/components/lr-menu-item.md

@@ -22,6 +22,10 @@ The inline semantic menu mapped from Shoelace's `sl-menu`, plus its action-row e
 wrapping keyboard navigation, type-ahead, and one canonical selection event. It deliberately has no
 trigger, positioned popup, root open state, placement API, or overlay lifecycle.
 
+Removing or disabling the remembered active item repairs the roving stop without taking focus from
+outside controls or the menu's header/footer. If the changed item held actual focus, focus moves to
+a valid survivor or through the existing owner dismissal path when none remain.
+
 For a menu button or other anchored overlay, compose the semantic controller inside
 `<lr-dropdown>`:
 

package/llms/components/lr-menu-label.md

@@ -25,9 +25,10 @@ name (`lr-menu-item` or `lr-dropdown-item`), not `instanceof`, so an adopted sam
 foreign-realm item remains enrollable. A label matches neither tag, is never enrolled in the roving
 tabindex, and can never become a focus stop; nothing on `<lr-menu>` has to know this element exists.
 
-To announce a _named group_ rather than a caption, wrap the labelled items in an element with
-`role="group"` and give it a matching `aria-label`. `aria-labelledby` pointing at this element's
-internals would not resolve — idrefs do not cross a shadow boundary.
+Keep selectable items directly assigned to the menu's default slot, or forward them through a
+slot, with `lr-menu-label` as a sibling visual caption. Arbitrary `role="group"` wrappers do not
+provide a supported menu-group API. `aria-labelledby` cannot reference this element's shadow
+internals because idrefs do not cross a shadow boundary.
 
 **Properties:** none. **Events:** none. **Slots:** default (the heading text).
 **CSS parts:** `base` (the heading row).

package/llms/components/lr-menu.md

@@ -22,6 +22,10 @@ The inline semantic menu mapped from Shoelace's `sl-menu`, plus its action-row e
 wrapping keyboard navigation, type-ahead, and one canonical selection event. It deliberately has no
 trigger, positioned popup, root open state, placement API, or overlay lifecycle.
 
+Removing or disabling the remembered active item repairs the roving stop without taking focus from
+outside controls or the menu's header/footer. If the changed item held actual focus, focus moves to
+a valid survivor or through the existing owner dismissal path when none remain.
+
 For a menu button or other anchored overlay, compose the semantic controller inside
 `<lr-dropdown>`:
 

package/llms/components/lr-message-actions.md

@@ -34,6 +34,9 @@ becomes unavailable, focus moves to the nearest survivor or the stable toolbar,
 newer external focus move. Keyboard movement starts from the action that actually received the event,
 even after a controlled state write changed the remembered stop.
 
+ArrowLeft/ArrowRight/Home/End from a slotted feedback comment editor remain native editing keys.
+Roving navigation still operates on the actual toolbar and thumb actions.
+
 **Properties:** `controls: MessageActionControl[] = []` (attribute: false) —
 `MessageActionControl = 'copy' | 'regenerate' | 'edit' | 'feedback'` (exported here); which built-ins
 render, in that order. Duplicate names are omitted first-wins before rendering, roving focus, or
@@ -41,19 +44,26 @@ intent events, so each built-in can occur at most once. `copyText: string = ''`
 (attribute `copy-text`) — required for the `copy` built-in to render at all. `feedbackRating:
 MessageFeedbackValue = null` (attribute `feedback-rating`) — forwarded to the embedded, thumbs-only
 `lr-message-feedback` (its `detail`/`detailFor` are never forwarded, so its detail panel never
-opens). `revealOnInteraction: boolean = false` (reflected, attribute `reveal-on-interaction`) — hides
+opens). `feedbackPending: boolean` (read-only, nonreflecting) — true only while the current built-in
+feedback control awaits settlement; it has no `feedback-pending` attribute or change event.
+`revealOnInteraction: boolean = false` (reflected, attribute `reveal-on-interaction`) — hides
 the bar until the closest `lr-chat-message` ancestor is hovered, or the toolbar contains focus.
 `label: string = ''` — accessible name override for the toolbar. `accessibleLabel: string | null =
 null` (attribute `aria-label`) — overrides the toolbar's computed accessible name, winning over
 `label` and the localized default; attribute-reflects from a host-level `aria-label`.
 
+**Methods:** `finalizePendingSubmit(submissionId: string): boolean` and
+`revertPendingSubmit(submissionId: string): boolean` settle only the current built-in feedback
+request. Both return `false` for blank, stale, mismatched, removed, or replaced requests.
+
 **Events:** `lr-regenerate`/`lr-edit` — a built-in was activated, `detail: null`. `lr-copy` —
 frozen `detail: { ok: true, text }`, emitted only after the embedded `lr-copy-button`'s clipboard
 write fulfills (bubbles/composed already, not re-emitted). A failed write surfaces generic
 `lr-error` (`detail: null`) plus `lr-copy-error` with frozen
 `detail: { ok: false, text, reason, error }`; `reason` is `'unsupported' | 'denied' | 'failed'`.
-`lr-feedback-change`/`lr-feedback-submit` — bubble unchanged from the embedded,
-thumbs-only `lr-message-feedback`. A colliding event from an
+`lr-feedback-change`/`lr-feedback-submit` — bubble unchanged from the embedded, thumbs-only
+`lr-message-feedback`; the frozen submit detail includes its `submissionId`, which is the value to
+pass to either settlement method. A colliding event from an
 arbitrary slotted child is contained at that slot boundary rather than being mistaken for a
 built-in action.
 

package/llms/components/lr-message-feedback.md

@@ -24,6 +24,10 @@ read-only display). Activating the pressed thumb while its detail panel is open
 activating the still-pressed thumb reopens it with the surviving draft. A thumbs-only control always
 uses the ordinary re-activate-to-clear toggle.
 
+Asynchronous finalization or reversion preserves focus on an outside control. Settlement retains the
+existing thumb/submit fallback when focus remains within the feedback or was lost as its pending
+controls became disabled.
+
 **Properties:** `rating: MessageFeedbackValue = null` (`'up' | 'down' | null`, reflected),
 `detail?: MessageFeedbackDetailConfiguration` (attribute: false) — one configuration with optional
 `reasons?: readonly { id, label }[]` and `commentable?: boolean`; omit it for thumbs-only feedback.
@@ -36,21 +40,34 @@ owns that one detail panel. `disabled: boolean = false` (reflected) makes a reco
 submission while host persistence is unresolved; all feedback controls are disabled and the panel
 reports busy until that state is resolved.
 
+When the optional comment textarea renders, `spellcheck: boolean = true`,
+`autocapitalize: string = ''`, `autocorrect: boolean = true`, and
+`wrap: MessageFeedbackWrap = 'soft'` forward to it; they have no effect without that textarea.
+`MessageFeedbackWrap` is `'soft' | 'hard' | 'off'`, the native textarea wrap vocabulary.
+
 **Methods:** `focus()` focuses the thumb matching the current `rating` (the up thumb when `null`);
 `blur()` blurs both thumbs; `click()` activates that same thumb when enabled.
 `getToolbarActions()` returns the ordered logical thumb actions used by an enclosing toolbar.
-`finalizePendingSubmit()` completes a prevented submit after persistence succeeds, closing the
-panel, announcing success, and returning focus to the active thumb. `revertPendingSubmit()` releases
-the pending state after failure without clearing the draft or announcing success, leaving the panel
-open for retry. Both are no-ops when no submit is pending.
+`finalizePendingSubmit(submissionId?: string): boolean` completes a prevented submit after persistence succeeds, closing the
+panel, announcing success, and returning focus to the active thumb.
+`revertPendingSubmit(submissionId?: string): boolean` releases
+the pending state after failure without clearing the draft or announcing success, restoring the
+prior rating and panel state. A detail-panel submit remains open for retry, while a thumbs-only
+submit remains panel-free; it likewise accepts an optional `submissionId` and returns `boolean`. The event
+supplies a nonblank, never-reused id; a later/current settlement must use that exact id. Legacy
+no-argument settlement remains available only for the first transaction that has never been
+invalidated; stale or mismatched settlements return `false`.
 
 **Events:** `lr-feedback-change` — `detail: { rating: 'up' | 'down' | null }`, fired when a thumb's
 provisional rating changes or clears. `lr-feedback-submit` — cancelable
-`detail: { rating: 'up' | 'down' | null; reasonIds: string[]; comment: string }`, fired for every
+`detail: { rating: 'up' | 'down' | null; reasonIds: string[]; comment: string; submissionId: string }`, fired for every
 terminal thumbs-only choice/clear and by the detail panel's submit button. The pending transaction
-is installed before dispatch, so even a synchronous listener may finalize/revert it safely.
+is installed before dispatch, so even a synchronous listener may finalize/revert it safely. The
+event detail is frozen.
 `preventDefault()` holds the panel/control in `pending` and delays
-success announcement/focus until `finalizePendingSubmit()`; call `revertPendingSubmit()` on failure.
+success announcement/focus until `finalizePendingSubmit(detail.submissionId)`; call
+`revertPendingSubmit(detail.submissionId)` on failure. The no-argument form is only the documented
+legacy first-transaction path.
 When uncanceled it retains the synchronous close/announce/focus behavior. The optional comment
 `<textarea>`'s native `focus` and `blur` are re-dispatched as bubbling, composed host events.
 `lr-toolbar-actions-change` is the no-detail coordination event emitted when the provider's logical

package/llms/components/lr-message-parts.md

@@ -18,17 +18,20 @@
 
 Ordered renderer for provider-neutral `MessagePart[]`: text, reasoning, tool call/result, citation,
 attachment, data/widget, audio, and error parts can interleave without flattening stream order.
-Built-in text and reasoning Markdown receives each part's `state === 'streaming'` hint, coalescing
-parse/highlight work; replacing that same-id part with `state: 'complete'` flushes the final content.
+Built-in text and reasoning Markdown receives each part's `state === 'streaming'` hint and displays
+accumulated plain text without parsing or highlighting. Replacing that same-id part with
+`state: 'complete'` parses and renders the final content.
 Citation badge ranks are precomputed in one linear pass per render, rather than rescanning and
 allocating every preceding part for each citation in a citation-heavy or growing message.
 
-**Properties:** `parts: MessagePart[] = []` (attribute: false); `contentMode: 'plain' | 'markdown' =
+**Properties:** `parts: MessagePart[] = []` (attribute: false); `contentMode: MessagePartsContentMode =
 'markdown'` (attribute `content-mode`, reflected) and `showReasoning: boolean = true` (attribute
 `show-reasoning`, reflected, with string-aware true-default conversion);
 `renderPart?: MessagePartRenderer` (attribute: false), where returning `undefined` delegates that
 part to the built-in renderer; `accessibleLabel: string | null = null` (attribute `aria-label`).
 
+Unsupported direct or `content-mode` attribute values normalize and reflect as `markdown`.
+
 `MessagePartRenderer = (part: MessagePart, index: number) => unknown`; `MessagePart` and its
 discriminated part shapes come from the `@aceshooting/lyra-ui/ai` subpath. Tool results are a strict
 success/error union: a success has `result` and cannot have `error`; an error has `error` and may

package/llms/components/lr-model-select.md

@@ -26,6 +26,14 @@ element. First-party invention (no Web Awesome equivalent).
 Session-history/autofill restoration synchronously restores the model id and form entry without
 emitting `lr-change`.
 
+Removing `label`, `hint`, or `error-text` clears that optional copy in both catalog and free-text
+modes. Removed string properties retain `null` readback, and later assignments restore their
+content.
+
+Composing key events (`isComposing` or legacy `keyCode === 229`) remain with the catalog query or
+custom-value editor: they do not navigate options, commit a selection or custom value, or close the
+popup. Ordinary keyboard behavior resumes after composition.
+
 When `catalog`/`allowCustom` replaces a focused trigger with the free-text input or vice versa,
 focus follows the available replacement. If the new owner is disabled or inert, focus returns to
 the available element that led into the picker, or to the stable `form-control` owner when no
@@ -78,6 +86,9 @@ focus move.
   they have no effect in closed-dropdown mode
 - `name: string = ''` (reflected)
 - `disabled: boolean = false` (reflected)
+- `readonly: boolean = false` (reflected) — prevents user typing and catalog
+  commits while retaining focus, popup navigation, selection/copy, submission/reset, and programmatic
+  writes.
 - `required: boolean = false` (reflected — enforced via `internals.setValidity()`)
 - `open: boolean = false` (reflected)
 - `size: LyraSize = 'm'` (reflected) — visual size on the library-wide ladder: `2xs`/`xs`/`s`/`m`/
@@ -177,8 +188,8 @@ every labelled control in the library uses, so `--lr-form-control-required-conte
 `--lr-form-control-required-color` and `--lr-form-control-required-offset` retune or suppress it here
 exactly as they do on `lr-input` (see `llms/shared.md` → "The required-field marker"). With no visible label there
 is nothing to mark and no stray glyph is rendered. Correspondingly, while the picker is barred from
-constraint validation — its own `disabled`, or an ancestor `<fieldset disabled>`; this control has no
-`readonly` — it reports no violation and publishes neither `:state(invalid)` nor
+constraint validation — its own `disabled` or `readonly`, or an ancestor `<fieldset disabled>` — it
+reports no violation and publishes neither `:state(invalid)` nor
 `:state(user-invalid)`, matching native `:invalid`. `required`/`optional` keep publishing.
 
 **CSS parts:** `form-control` (the complete label, control, hint, error, and listbox frame),

package/llms/components/lr-multi-split.md

@@ -21,6 +21,13 @@ auto-inserted between each adjacent pair. Panels participating in persistence ca
 nonempty, whitespace-stable `panel-id`; this business identity stays independent from the platform
 `id` attribute and is never rewritten.
 
+Feasible `minPx` floors also constrain flex shrinking after the divider target gutters take their
+allocation: a 600px split with a 40px divider can render panels of 300px and 260px. If the floors
+cannot fit, the remaining panel space is shared proportionally instead of overflowing. The budget
+follows allocation and the actual divider geometry, including font-relative tokens resolved in the
+divider's own font context. Panel font sizes do not change that gutter budget; stored percentages,
+initialization precedence, and resize event values retain their existing meaning.
+
 Granular import: `@aceshooting/lyra-ui/components/layout/multi-split/multi-split.js`.
 The Lyra-original v9 identity migration is mechanical: `lr-split` → `lr-multi-split`,
 `LyraSplit` → `LyraMultiSplit`, generic container authoring types → the corresponding
@@ -28,10 +35,10 @@ The Lyra-original v9 identity migration is mechanical: `lr-split` → `lr-multi-
 `--lr-split-*` hooks/storage keys → `--lr-multi-split-*`/`lr-multi-split:*`. The separate mirrored
 `lr-split-panel`, its `LyraSplitPanel` class, `SnapFunction`, and `SNAP_NONE` are unchanged.
 
-With a definite block size, each direct panel owns a native `overflow: auto` scroll surface and has
-`min-block-size: 0`, so long content stays inside the split rather than escaping into following
-content. Set `overflow` directly on an individual panel when its content needs a different scrolling
-surface.
+With a definite block size, each direct panel owns a native `overflow: auto` scroll surface.
+Unconstrained panels have a zero block minimum, so long content stays inside the split rather than
+escaping into following content. Set `overflow` directly on an individual panel when its content
+needs a different scrolling surface.
 
 **Properties:**
 
@@ -97,8 +104,10 @@ number; maxPx?: number; minPercent?: number; maxPercent?: number }`, index-align
   side resolves to the stricter one (larger for min, smaller for max) via a native CSS `max()`/`min()`
   in the rendered `clamp()` flex-basis. `sizes`, the `lr-resize` payload, and localStorage persistence
   stay percent-based regardless — only the effective drag/keyboard clamp bounds (and the rendered
-  `flex-basis`, via a native CSS `clamp()` so a constrained panel stays pinned between its bounds
-  across container resizes with no extra `ResizeObserver`) change for a constrained panel.
+  `flex-basis`, via a native CSS `clamp()` across container resizes) change for a constrained panel.
+  Pixel minimums also account for live divider dimensions. Bounds on neighboring panels remain
+  active during collapse transitions, including when constraints are updated from an
+  `lr-multi-split-collapse-change` handler.
 - `collapse: 'start'|'end'|'none' = 'none'` (reflected) — opt-in responsive collapse for one panel:
   `'start'`/`'end'` is a _logical_ position (RTL-aware, matching CSS logical properties — the panel at
   the document's visual leading/trailing edge, not a raw array index). `lr-multi-split` only owns the
@@ -156,7 +165,7 @@ number; maxPx?: number; minPercent?: number; maxPercent?: number }`, index-align
   renders nothing (`hidden`, out of the accessibility tree) instead of the always-visible overlay
   card this state rendered before `open` existed. Setting `open = true` reveals it as a
   focus-trapped floating panel with a `[part="backdrop"]` scrim; Escape or a backdrop click set
-  `open` back to `false`. While open, the floating panel is the modal root and every sibling pane
+  proposes a cancelable close before changing `open`. While open, the floating panel is the modal root and every sibling pane
   behind it is inert. Leaving `'floating'` while `open` is still `true` also closes it, the same
   way `<lr-app-rail>` closes its mobile overlay when leaving `'mobile'` while open.
 
@@ -179,6 +188,10 @@ or keyboard step commits. A genuine pointer gesture has one terminal persistence
 release emits no additional event; direct `sizes` assignments stay silent),
 `lr-multi-split-collapse-change` (`detail: { state: 'wide'|'rail'|'floating' }`, fired only
 on a real `collapse`-state transition, never on every resize/render),
+`lr-toggle` (`detail: LyraMultiSplitToggleDetail = { open: boolean }`) — Escape/backdrop close
+proposals are cancelable and fire before `open` changes; preventing the event or making a synchronous
+reentrant mutation aborts the proposal. A forced close when a responsive collapse transition leaves
+`floating` fires noncancelably after `open` is false. Direct `open` writes and no-op dismissals are silent,
 `lr-multi-split-constraints-invalid` (`detail: LyraMultiSplitConstraintIssueDetail`, fired once when the configured
 panel minimums/maximums cannot fit the track; the infeasible set is rejected for interaction and a
 normalized percent minimum is used instead), `lr-multi-split-orientation-change` (`detail: { orientation }`,

package/llms/components/lr-mutation-observer.md

@@ -31,6 +31,14 @@ form of `attr`, equivalent to `attr: '*'`) and `characterData` (`character-data`
 `charData`). Plus `subtree: boolean = true`, and programmatic `attributeFilter: string[] = []`
 (neither reflects).
 
+The browser capability is optional. A missing or throwing owner-window lookup, or an unavailable or
+throwing constructor, leaves that rebuild inert rather than leaking an exception. Individual
+`observe` and `disconnect` failures are contained, so later valid targets and later rebuilds can still observe.
+Callbacks from a retired document are ignored after disconnect or adoption. `attributeFilter` is
+likewise a bounded own-data snapshot (examining at most its first 10,000 direct data entries);
+malformed or accessor-backed entries are skipped, a valid prefix remains active, and an entirely
+unusable value falls back to an empty filter.
+
 **Events:** `lr-mutation`; its detail and bounded readonly record sequence are frozen.
 `detail.records` and mapped `detail.mutationList` reference the same sequence, while each native
 `MutationRecord` retains identity.

package/llms/components/lr-native-time-input.md

@@ -22,6 +22,16 @@ forces its internal native input to `type="time"` on construction and reconnect,
 as numbers. Use it when the browser/OS picker is preferred; new `wa-time-input` migrations should
 use the segmented `lr-time-input` above.
 
+`stepUp()` and `stepDown()` use the current `value`, `step`, `min`, and `max` properties in the same
+synchronous call, including changes made immediately beforehand. They preserve native step alignment
+and bounds, update form submission silently, and remain no-ops before the native input has rendered
+or while disabled/readonly. Native `step="any"` remains a non-steppable no-op.
+
+Changing own `disabled` from true to false in the same task that disables an ancestor fieldset keeps
+the native editing control effectively disabled. The enabled first-legend exception and explicit
+own-disabled state retain their native meaning; validity and form submission follow the effective
+disabled state.
+
 **Inherits:** all public surface from `lr-input`.
 
 All `lr-input` properties, form methods, events, label/hint/error/start/end slots, parts, and theme

package/llms/components/lr-node-palette.md

@@ -22,6 +22,9 @@ at `lr-node-add`/`lr-palette-place`; the host mutates `nodes`. Fully decoupled f
 `lr-flow-canvas` (no `for` resolution, unlike the other three companions) — it only needs to agree
 with a `droppable` canvas on the `FLOW_PALETTE_MIME_TYPE` drag payload shape.
 
+For `lr-palette-place`, create the node and assign the updated array to the target canvas's public
+`nodes` property. Updating a captured local array alone does not update an already rendered canvas.
+
 **Properties:**
 
 - `items: LyraPaletteItem[] = []` (attribute: false) — `LyraPaletteItem { type: string; label: string;
@@ -30,9 +33,12 @@ description?: string; category?: string; keywords?: string[]; icon?: unknown; di
   first-appearance-ordered headings, `disabled` renders an item visible but not draggable/placeable.
   A non-array value is treated as empty. Rows require nonblank string `type` and `label` values;
   malformed optional `description`, `category`, `keywords`, or `disabled` values omit only that row,
-  preserving later valid entries
+  preserving later valid entries. At most 10,000 positions are examined through own data
+  descriptors; accessor-backed rows are omitted without reserving later valid rows. The frozen
+  projection drives display while `lr-select.detail.item` retains the original admitted identity
 - `label?: string` — accessible name for the search field/listbox; omission uses the localized
-  palette label, while an explicit empty string stays empty
+  palette label. An omitted, empty, or whitespace-only value uses that fallback without changing
+  the raw property readback
 - `reorderable: boolean = false` (reflected) — opts into Ctrl/Cmd+ArrowUp/ArrowDown keyboard
   reordering of the catalog. Unset, no `lr-reorder` is ever emitted and Ctrl/Cmd+Arrow keeps
   behaving exactly like a plain Arrow press

package/llms/components/lr-notebook-viewer.md

@@ -32,7 +32,10 @@ are removed, and only inline base64 raster image sources render. Sanitized `imag
 is likewise network-silent and non-interactive: animation is removed and only same-document
 fragment references or inline base64 raster image references survive.
 Cells are virtualized through `lr-virtual-list`. `node-path` anchors resolve `path[0]` as a cell
-index; `fragment` anchors resolve a cell's own `id`. No execution, no kernels, no editing, no
+index; `fragment` anchors resolve a cell's own `id`. For cells with IDs, successful public anchor
+navigation scrolls the matching virtual row into the notebook allocation and applies active-cell
+paint using that same ID. Repeating a target scrolls back to it after manual scrolling.
+`maxHeight` also bounds the child virtual viewport. No execution, no kernels, no editing, no
 ipywidgets.
 
 **Properties:** `src: string = ''` — URL to fetch and parse as a notebook; ignored while `notebook`

package/llms/components/lr-number-input.md

@@ -20,6 +20,16 @@ A numeric field with the complete `lr-input` form, validation and native-editing
 own increment/decrement stepper pair. Its constructor and `connectedCallback()` both force
 `type = 'number'`; all inherited `lr-input` form and editing APIs remain available.
 
+`stepUp()` and `stepDown()` use the current `value`, `step`, `min`, and `max` properties in the same
+synchronous call, including changes made immediately beforehand. They preserve native step alignment
+and bounds, update form submission silently, and remain no-ops before the native input has rendered
+or while disabled/readonly. Native `step="any"` remains a non-steppable no-op.
+
+Changing own `disabled` from true to false in the same task that disables an ancestor fieldset keeps
+the native editing control effectively disabled. The enabled first-legend exception and explicit
+own-disabled state retain their native meaning; validity and form submission follow the effective
+disabled state.
+
 **Inherits:** all public surface from `lr-input`.
 
 The inherited `--lr-input-*` theme inputs keep `lr-input`'s ancestor-theme precedence; the number
@@ -30,7 +40,8 @@ action-height ladder as `lr-input` instead of remaining at the default tier for
 **Properties:** `size` (`2xs`…`xl`), `appearance`, `pill`, `autofocus`, `placeholder`, `readonly`,
 `label`, `hint`, `errorText`
 (`error-text`), `accessibleLabel` (`aria-label`), `autocomplete`, `spellcheck`, `autocapitalize`,
-`autoCorrect` (`autocorrect`), `inputMode` (`inputmode`), `enterKeyHint` (`enterkeyhint`), and
+`autocorrect` (boolean readback; accepts `boolean | 'off' | 'on'` writes), `inputMode`
+(`inputmode`), `enterKeyHint` (`enterkeyhint`), and
 `min`/`max`/`step` (the native numeric constraint validation), all inherited from `lr-input` with
 identical meaning. This component changes the mapped defaults to `appearance='outlined'`,
 `inputMode='numeric'`, and `step=1`. `clearable` (and its `with-clear` spelling),