@aceshooting/lyra-ui 3.8.0 → 3.9.0

package/custom-elements.json

@@ -8,7 +8,7 @@
       "declarations": [
         {
           "kind": "class",
-          "description": "`<lyra-activity-feed>` — an append-only streaming log of granular agent actions (\"Searching the\nweb…\", \"Read src/index.ts\"), collapsing to a localized \"Completed N steps\" summary once the run\nis over. Entries never change state once added (a step whose status mutates in place belongs to\n`<lyra-task-list>` instead). Implements the shared follow (stick-to-bottom) contract: `follow`\nis a component-managed, host-assignable property, released on user scroll-up and re-engaged at\nthe bottom, firing `lyra-follow-change` on every transition (mount excluded). At/above\n`virtualizeThreshold` entries, the body renders through an internal `<lyra-virtual-list>`\ninstead of a plain keyed list — same list semantics either way, keyed by `id`.",
+          "description": "`<lyra-activity-feed>` — an append-only streaming log of granular agent actions (\"Searching the\nweb…\", \"Read src/index.ts\"), collapsing to a localized \"Completed N steps\" summary once the run\nis over. Entries never change state once added (a step whose status mutates in place belongs to\n`<lyra-task-list>` instead). Implements the shared follow (stick-to-bottom) contract: `follow`\nis a component-managed, host-assignable property, released on user scroll-up and re-engaged at\nthe bottom, firing `lyra-follow-change` on every transition (mount excluded). At/above\n`virtualizeThreshold` entries, the body renders through an internal `<lyra-virtual-list>`\ninstead of a plain keyed list — same list semantics either way, keyed by `id`.\n\nEach entry's `text` renders as plain text by default; a host needing richer per-entry content\n(rendered markdown, a trailing tool-call chip list, etc.) sets `renderText` to fully replace it,\nidentically whether or not the feed is currently virtualized.",
           "name": "LyraActivityFeed",
           "cssProperties": [
             {
@@ -35,7 +35,7 @@
               "name": "entry-icon"
             },
             {
-              "description": "The entry's `text`.",
+              "description": "The entry's `text`. Not rendered while `renderText` is set — its returned content replaces this part entirely.",
               "name": "entry-text"
             },
             {
@@ -259,6 +259,14 @@
                 "module": "src/internal/lyra-element.ts"
               }
             },
+            {
+              "kind": "field",
+              "name": "renderText",
+              "type": {
+                "text": "(entry: ActivityEntry) => TemplateResult | undefined"
+              },
+              "description": "Overrides the default plain-text `[part=\"entry-text\"]` rendering of every entry with an\narbitrary `TemplateResult` (e.g. rendered markdown, or markdown plus a trailing list of\n`<lyra-tool-call-chip>`s) — the returned content fully replaces `[part=\"entry-text\"]` rather\nthan augmenting it, the same way `formatTimestamp` fully replaces the default timestamp\nformatting. Applies identically whether or not the feed is currently virtualized, since both\npaths render every entry through the same internal template."
+            },
             {
               "kind": "field",
               "name": "scrollRafId",
@@ -81636,6 +81644,11 @@
               "name": "--lyra-graph-selected-color",
               "default": "var(--lyra-color-success)"
             },
+            {
+              "description": "Opacity applied to a node/link when `dimmedNodeIds`/`dimmedLinkIds` includes its id (both SVG and canvas renderers). `1` (the default) is a no-op -- an unset host sees no visual change.",
+              "name": "--lyra-graph-dimmed-opacity",
+              "default": "1"
+            },
             {
               "description": "Hull fill/stroke color.",
               "name": "--lyra-graph-hull-fill",
@@ -81957,6 +81970,24 @@
                 "module": "src/internal/lyra-element.ts"
               }
             },
+            {
+              "kind": "field",
+              "name": "dimmedLinkIds",
+              "type": {
+                "text": "string[]"
+              },
+              "default": "[]",
+              "description": "Same contract as `dimmedNodeIds`, for links. A link's dimming key is the same `linkKey()`\nvalue (`GraphLink.id`, else `` `${source}->${target}` ``) `selectedLinkIds` already uses."
+            },
+            {
+              "kind": "field",
+              "name": "dimmedNodeIds",
+              "type": {
+                "text": "string[]"
+              },
+              "default": "[]",
+              "description": "Node ids to render dimmed (`data-dimmed` on the matching `[part=\"node\"]`, themeable via\n`--lyra-graph-dimmed-opacity`). Controlled, mirroring `selectedNodeIds`/`selectedLinkIds`: the\ncomponent never assigns this itself, only renders it -- a host typically computes it from a\n`lyra-node-enter`/`lyra-link-enter` hover (the complement of the hovered id's neighbor set,\ncomputed from the host's own `links` array) and assigns the result back. Empty (the default)\nrenders every node at full opacity, unchanged from today."
+            },
             {
               "kind": "field",
               "name": "edgeLabelMinZoom",
@@ -83117,6 +83148,30 @@
                 }
               ]
             },
+            {
+              "kind": "method",
+              "name": "isDimmed",
+              "privacy": "private",
+              "return": {
+                "type": {
+                  "text": "boolean"
+                }
+              },
+              "parameters": [
+                {
+                  "name": "kind",
+                  "type": {
+                    "text": "'node' | 'link'"
+                  }
+                },
+                {
+                  "name": "id",
+                  "type": {
+                    "text": "string"
+                  }
+                }
+              ]
+            },
             {
               "kind": "method",
               "name": "isSelected",
@@ -90800,7 +90855,7 @@
       "declarations": [
         {
           "kind": "class",
-          "description": "`<lyra-input>` — a single-line plain-text input primitive, the `lyra-*` equivalent of a plain\n`wa-input`, form-associated via the `FormAssociated` mixin (same shape as `<lyra-textarea>`).\n\nShips the same opt-in `label`/`hint`/`errorText` form-control chrome as `<lyra-textarea>`/\n`<lyra-select>` (props + matching named slots + `form-control`/`form-control-label`/`hint`/`error`\nparts) — left unset, the chrome stays hidden. `size` uses the same `xs`–`xl` scale as\n`<lyra-select>`/`<lyra-combobox>`. `type=\"password\"` always renders a\n`password-toggle` eye-icon button that flips the internal native input between\n`type=\"password\"`/`type=\"text\"` and tracks `passwordVisible`. `type=\"email\"`/`type=\"number\"`\n(with `min`/`max`/`step`) delegate constraint validation to the internal native `<input>`'s own\nbrowser-computed `validity`, bridged into this element's `ElementInternals` by `updateValidity()`.\n\nA host `aria-label` is forwarded to the internal textbox via the typed `accessibleLabel` property;\nexternal `aria-labelledby`/`aria-describedby` idrefs are not copied across the shadow boundary.",
+          "description": "`<lyra-input>` — a single-line plain-text input primitive, the `lyra-*` equivalent of a plain\n`wa-input`, form-associated via the `FormAssociated` mixin (same shape as `<lyra-textarea>`).\n\nShips the same opt-in `label`/`hint`/`errorText` form-control chrome as `<lyra-textarea>`/\n`<lyra-select>` (props + matching named slots + `form-control`/`form-control-label`/`hint`/`error`\nparts) — left unset, the chrome stays hidden. `size` uses the same `xs`–`xl` scale as\n`<lyra-select>`/`<lyra-combobox>`. `type=\"password\"` always renders a\n`password-toggle` eye-icon button that flips the internal native input between\n`type=\"password\"`/`type=\"text\"` and tracks `passwordVisible`. `type=\"email\"`/`type=\"number\"`\n(with `min`/`max`/`step`) delegate constraint validation to the internal native `<input>`'s own\nbrowser-computed `validity`, bridged into this element's `ElementInternals` by `updateValidity()`.\n`type=\"search\"`/`type=\"time\"` forward straight through to the native input with no additional\nchrome or validation, the same as `type=\"text\"`.\n\nA host `aria-label` is forwarded to the internal textbox via the typed `accessibleLabel` property;\nexternal `aria-labelledby`/`aria-describedby` idrefs are not copied across the shadow boundary.",
           "name": "LyraInput",
           "cssParts": [
             {
@@ -98721,43 +98776,1176 @@
             },
             {
               "kind": "method",
-              "name": "tryConstructMap",
+              "name": "tryConstructMap",
+              "privacy": "private",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              },
+              "description": "Constructs the underlying `maplibregl.Map` — called once both the\nlazy-loaded `maplibre-gl` module has resolved and this element has been\nobserved intersecting the viewport, whichever settles last. Idempotent\n(a no-op once `_map` already exists), so it's safe to call from both the\n`connectedCallback()` load path and the visibility path in `updated()`\nbelow without risking a double construction."
+            }
+          ],
+          "events": [
+            {
+              "description": "`detail: { lngLat, feature? }`.",
+              "name": "lyra-map-click"
+            },
+            {
+              "description": "Fired once the underlying maplibregl.Map loads.",
+              "name": "lyra-map-load"
+            }
+          ],
+          "attributes": [
+            {
+              "name": "center",
+              "type": {
+                "text": "[number, number]"
+              },
+              "default": "[0, 0]",
+              "fieldName": "center"
+            },
+            {
+              "name": "label",
+              "type": {
+                "text": "string"
+              },
+              "default": "''",
+              "description": "Accessible name fallback for the map group. A host `aria-label` takes\nprecedence when both are set; when neither is present, the group uses\nthe localized `map` message.",
+              "fieldName": "label"
+            },
+            {
+              "name": "locale",
+              "type": {
+                "text": "string"
+              },
+              "default": "''",
+              "description": "Optional locale override. Otherwise the nearest `locale`/`lang` ancestor is used.",
+              "fieldName": "locale",
+              "inheritedFrom": {
+                "name": "LyraElement",
+                "module": "src/internal/lyra-element.ts"
+              }
+            },
+            {
+              "name": "zoom",
+              "type": {
+                "text": "number"
+              },
+              "default": "2",
+              "fieldName": "zoom"
+            }
+          ],
+          "superclass": {
+            "name": "LyraElement",
+            "module": "/src/internal/lyra-element.js"
+          },
+          "tagName": "lyra-map",
+          "customElement": true
+        }
+      ],
+      "exports": [
+        {
+          "kind": "js",
+          "name": "LyraMap",
+          "declaration": {
+            "name": "LyraMap",
+            "module": "src/components/map/map.class.ts"
+          }
+        }
+      ]
+    },
+    {
+      "kind": "javascript-module",
+      "path": "src/components/map/map.ts",
+      "declarations": [],
+      "exports": [
+        {
+          "kind": "custom-element-definition",
+          "name": "lyra-map",
+          "declaration": {
+            "name": "LyraMap",
+            "module": "src/components/map/map.class.ts"
+          }
+        },
+        {
+          "kind": "js",
+          "name": "*",
+          "declaration": {
+            "name": "*",
+            "module": "src/components/map/map.class.js"
+          }
+        }
+      ]
+    },
+    {
+      "kind": "javascript-module",
+      "path": "src/components/markdown/katex-loader.ts",
+      "declarations": [
+        {
+          "kind": "function",
+          "name": "getKatex",
+          "return": {
+            "type": {
+              "text": "Promise<KatexApi | null>"
+            }
+          },
+          "parameters": [
+            {
+              "name": "importKatex",
+              "optional": true,
+              "type": {
+                "text": "() => Promise<{ default: KatexApi } | KatexApi>"
+              }
+            }
+          ],
+          "description": "Lazily loads `katex` once per page, caching the resolved module (or `null`) across every\n`<lyra-markdown>` instance -- mirrors `markdown-loader.ts`'s `loadMarkdownDeps()`/\n`getMarkdownDepsIfLoaded()` cached-promise shape for a single optional peer."
+        },
+        {
+          "kind": "function",
+          "name": "loadKatex",
+          "return": {
+            "type": {
+              "text": "Promise<KatexApi | null>"
+            }
+          },
+          "parameters": [
+            {
+              "name": "importKatex",
+              "default": "() =>\n    import('katex') as Promise<{ default: KatexApi }>",
+              "type": {
+                "text": "() => Promise<{ default: KatexApi } | KatexApi>"
+              }
+            }
+          ],
+          "description": "Loads the optional peer dependency `katex`, used by `<lyra-markdown>`'s `math` property to\nrender `$...$`/`$$...$$` TeX as MathML. Resolves `null` (with a one-time `console.warn`) if the\npeer isn't installed -- rendering falls back to the literal, unparsed TeX source in that case,\na fully supported default rather than a degraded mode. Mirrors `dompurify-loader.ts`'s single-\noptional-peer shape."
+        }
+      ],
+      "exports": [
+        {
+          "kind": "js",
+          "name": "getKatex",
+          "declaration": {
+            "name": "getKatex",
+            "module": "src/components/markdown/katex-loader.ts"
+          }
+        },
+        {
+          "kind": "js",
+          "name": "loadKatex",
+          "declaration": {
+            "name": "loadKatex",
+            "module": "src/components/markdown/katex-loader.ts"
+          }
+        }
+      ]
+    },
+    {
+      "kind": "javascript-module",
+      "path": "src/components/markdown/markdown-core.class.ts",
+      "declarations": [
+        {
+          "kind": "class",
+          "description": "`<lyra-markdown-core>` — a build-lean variant of `<lyra-markdown>` for a consumer whose\n`languages` map already covers every language it will ever render. Every other capability (GFM\ntables, fenced code blocks, links, blockquotes, heading anchors, text-quote highlights, math) is\nidentical to `<lyra-markdown>` -- only fenced-code-block highlighting differs: this component's\nown module never textually contains a call to (or import of) `loadShikiHighlighter` (the\n~200-language default dynamic-import table `<lyra-markdown>` calls unconditionally unless its\n*runtime* `languagesOnly` flag is `true` -- a flag on that same module a bundler can't prove\nalways-true, so the unconditional call stays in the build output regardless). A consumer\nimporting this entry point instead of `markdown.js` gets a genuinely shiki-full-table-free\nbuild. A fenced block whose language isn't a key in `languages` always renders the plain-text\nfallback -- there is no default/full-table highlighter here to fall back to, mirroring\n`<lyra-code-block-core>`'s identical contract for the sibling component.\n\nBuilt on the optional peer dependencies `marked` (parsing) and `dompurify` (sanitizing), both\nlazy-loaded via `markdown-loader.ts` on first connect.\n\nRendering never ships unsanitized or broken markup silently:\n- If `marked` fails to load, or throws while parsing malformed input, the\n  component falls back to plain text (`white-space: pre-wrap`, no HTML\n  parsing at all) and fires `lyra-render-error`.\n- If `sanitize` is `true` (the default) and `dompurify` fails to load, the\n  component *also* falls back to plain text + `lyra-render-error` — it\n  never renders marked's raw HTML output when sanitization was requested\n  (or defaulted to) but is unavailable, even though `marked` itself loaded\n  fine.\n- If `sanitize` is explicitly `false`, marked's raw output renders as-is\n  regardless of whether `dompurify` is installed — the consumer opted out\n  of sanitization, so `dompurify`'s absence is irrelevant to that path.\n\nThat same plain-text fallback rendering (`data-fallback` on the `content`\npart) is also, unconditionally and by default, a brief *transient* state on\nevery connect, not just a failure path: `connectedCallback()`'s dynamic\n`import()` of `marked`/`dompurify` (see `markdown-loader.ts`) is\nasynchronous, so the very first paint of any `<lyra-markdown>` on a page\nshows plain text for at least one microtask — even when both peers are\nalready installed and load without error — until that import resolves and\na second render replaces it with the real Markdown output. Set\n`eager-load` to skip that window once the shared dependency cache is\nalready warm; see that property's doc for exactly what \"warm\" requires.\n\n`heading`/`code`/`blockquote`/`table`/`link`/`image` tokens are rendered\nthrough a `marked` renderer override that injects `part=\"...\"` attributes\ndirectly into the produced HTML — a single pass, not a second DOM walk\nafter insertion.\n\nFenced code blocks are syntax-highlighted via the same fine-grained `shiki/core` recipe\n`<lyra-code-block-core>` uses (`highlightCode`, default `true` — gated by whether a fenced\nblock's language is a key in `languages`, since there is no default highlighter here to gate on\n\"is shiki installed at all\"). The very first render of any content is always plain (identical to\n`<lyra-markdown>`'s own output); highlighting arrives as an asynchronous upgrade one render\nlater, once the fine-grained highlighter resolves. No highlighting is attempted while\n`streaming` is `true` — it applies once a stream settles, so there is no added per-chunk cost\nwhile content is still arriving.\n\nWhen `heading-anchors` is set, every rendered heading's slug (computed via the shared\nGitHub-slugger-style `Slugger`) is stamped as its `id`; `getHeadingTree()` computes that same\noutline on every parse regardless of `heading-anchors`, so a host can build a table of contents\neven while ids aren't in the DOM yet. `scrollToAnchor()` (from the adopted `DocumentAnchorTarget`\nmixin) resolves `fragment` anchors against that outline and `text-quote` anchors via\n`internal/text-quote.ts`'s shared scope/resolve helpers; `highlights` re-resolve by quote after\nevery render (never by node identity), so a highlight painted before a `streaming` update\nfinishes still finds its quote once the matching text arrives. Highlight painting uses\n`internal/text-highlights.ts`'s `acquireHighlightHandle()` -- the CSS Custom Highlight API where\nthe browser supports it (no DOM mutation at all), a `<mark>`-wrap fallback otherwise.\n\n`math` renders `$...$`/`$$...$$` TeX as MathML via the optional `katex` peer's\n`renderToString(tex, { output: 'mathml' })` -- MathML Core renders natively and accessibly in\nevergreen browsers with no extra stylesheet or webfont needing to cross the shadow boundary. A\nmissing `katex` peer renders the literal, unparsed TeX source (delimiters included) and fires one\n`lyra-render-error`.",
+          "name": "LyraMarkdownCore",
+          "cssParts": [
+            {
+              "description": "Every rendered `<blockquote>`.",
+              "name": "blockquote"
+            },
+            {
+              "description": "Every rendered fenced/indented `<pre>`.",
+              "name": "code-block"
+            },
+            {
+              "description": "The wrapper around the rendered (or plain-text fallback) output.",
+              "name": "content"
+            },
+            {
+              "description": "Every rendered `<h1>`–`<h6>` (shifted by `heading-offset`).",
+              "name": "heading"
+            },
+            {
+              "description": "Every rendered `<img>`.",
+              "name": "img"
+            },
+            {
+              "description": "Every rendered inline `<code>` span (backtick spans, not fenced blocks).",
+              "name": "inline-code"
+            },
+            {
+              "description": "Every rendered `<a>`.",
+              "name": "link"
+            },
+            {
+              "description": "Every rendered `<ul>`/`<ol>`.",
+              "name": "list"
+            },
+            {
+              "description": "A rendered inline or block math span (`data-display=\"inline\"|\"block\"`).",
+              "name": "math"
+            },
+            {
+              "description": "Every rendered `<p>`.",
+              "name": "paragraph"
+            },
+            {
+              "description": "Every rendered `<table>`.",
+              "name": "table"
+            }
+          ],
+          "members": [
+            {
+              "kind": "field",
+              "name": "anchorKinds",
+              "type": {
+                "text": "readonly LyraAnchorKind[]"
+              },
+              "readonly": true,
+              "default": "['fragment', 'text-quote']",
+              "description": "Anchor kinds this component resolves via `scrollToAnchor()`. Readonly."
+            },
+            {
+              "kind": "field",
+              "name": "content",
+              "type": {
+                "text": "string"
+              },
+              "default": "''",
+              "description": "The Markdown source to render.",
+              "attribute": "content"
+            },
+            {
+              "kind": "field",
+              "name": "deferredLoad",
+              "type": {
+                "text": "() => void | undefined"
+              },
+              "privacy": "private",
+              "inheritedFrom": {
+                "name": "LyraElement",
+                "module": "src/internal/lyra-element.ts"
+              }
+            },
+            {
+              "kind": "field",
+              "name": "deps",
+              "type": {
+                "text": "MarkdownDeps | undefined"
+              },
+              "privacy": "private"
+            },
+            {
+              "kind": "field",
+              "name": "eagerLoad",
+              "type": {
+                "text": "boolean"
+              },
+              "default": "false",
+              "description": "When `true`, `connectedCallback()` skips awaiting `loadMarkdownDeps()`'s\ndynamic `import()` if the shared `marked`/`dompurify` module cache (see\n`markdown-loader.ts`'s `getMarkdownDepsIfLoaded()`) has *already*\nresolved — e.g. because an earlier `<lyra-markdown>` instance on the\npage already finished loading, or the consumer primed the cache\ndirectly by calling `loadMarkdownDeps()` themselves at startup — and\nrenders synchronously instead. When the cache isn't warm yet (most\nnotably: the very first `<lyra-markdown>` ever connected on a page,\nsince nothing has called `loadMarkdownDeps()` before it), this still\nfalls back to the normal async path — a dynamic `import()` can't be\nmade synchronous, so this is a fast path for the common \"already warm\"\ncase, not a hard guarantee. `false` (the default) is byte-identical to\ntoday: always the async `import()`, fallback-text window included.",
+              "attribute": "eager-load"
+            },
+            {
+              "kind": "field",
+              "name": "effectiveDirection",
+              "type": {
+                "text": "'ltr' | 'rtl'"
+              },
+              "privacy": "protected",
+              "description": "The effective text direction, including inherited CSS direction.",
+              "readonly": true,
+              "inheritedFrom": {
+                "name": "LyraElement",
+                "module": "src/internal/lyra-element.ts"
+              }
+            },
+            {
+              "kind": "field",
+              "name": "effectiveLocale",
+              "type": {
+                "text": "string"
+              },
+              "privacy": "protected",
+              "description": "The effective locale used by this component.",
+              "readonly": true,
+              "inheritedFrom": {
+                "name": "LyraElement",
+                "module": "src/internal/lyra-element.ts"
+              }
+            },
+            {
+              "kind": "field",
+              "name": "escapeHtml",
+              "type": {
+                "text": "boolean"
+              },
+              "default": "false",
+              "description": "When `true`, overrides marked's `html` renderer hook to emit the HTML-escaped source text\ninstead of passing raw/sanitized markup through -- for a consumer rendering arbitrary\nalready-written content (e.g. a historical chat/agent transcript full of code/XML/HTML\nsnippets) where a stray angle bracket should render as visible text, not a real DOM element.\nStill lets GFM tables/lists/etc. render normally -- only raw embedded HTML is affected.\n`false` (the default) reproduces today's exact `marked`-default (sanitized-when-`sanitize`)\npassthrough behavior.",
+              "attribute": "escape-html"
+            },
+            {
+              "kind": "field",
+              "name": "failedHighlightKeys",
+              "privacy": "private",
+              "default": "new Set<string>()",
+              "description": "Keys from `PendingHighlight` that failed to highlight -- peer missing, language unrecognized,\nor tokenization threw. Once a key lands here, `code()` stops re-discovering it as pending on\nevery future render. Without this, a permanently-unhighlightable block (e.g. an unrecognized\nlanguage) would never get cached, so every `renderMarkdown()` pass -- including the one\n`highlightPending()` itself triggers on completion -- would rediscover it as pending and retry\nit again, forever. Mirrors `code-loader.ts`'s own `unsupportedLanguages` Set, which exists for\nthe identical reason one level down (a single unrecognized `language` value on\n`<lyra-code-block>`)."
+            },
+            {
+              "kind": "field",
+              "name": "gfm",
+              "type": {
+                "text": "boolean"
+              },
+              "default": "true",
+              "description": "Enable GitHub-flavored Markdown (tables, strikethrough, autolinks, task lists).",
+              "attribute": "gfm"
+            },
+            {
+              "kind": "field",
+              "name": "headingAnchors",
+              "type": {
+                "text": "boolean"
+              },
+              "default": "false",
+              "description": "Stamps a computed slug as `id` on every rendered heading. `getHeadingTree()` computes the\nsame slugs regardless of this property -- it only controls whether the `id` attribute is\nemitted into the rendered DOM. `false` (the default) preserves today's exact output.\n\nWhen `sanitize` is also on (the default), a slug whose *value* collides with a real\n`document` property name (e.g. a heading literally titled \"Title\", \"Location\", or \"Forms\"\nslugs to `title`/`location`/`forms`) has its `id` silently stripped by DOMPurify's DOM-\nclobbering protection (`SANITIZE_DOM`) -- `getHeadingTree()` still reports that heading's slug\neither way, but `scrollToAnchor({ kind: 'fragment', id })` still resolves it correctly even\nwithout a DOM `id` present, via its own position-based fallback lookup.",
+              "attribute": "heading-anchors"
+            },
+            {
+              "kind": "field",
+              "name": "headingOffset",
+              "type": {
+                "text": "number"
+              },
+              "default": "0",
+              "description": "Added to every rendered heading's source `token.depth` before emitting\n`<h${depth}>` — e.g. `heading-offset=\"2\"` renders a source `#` as\n`<h3>` and a source `##` as `<h4>`. The result is clamped to `[1, 6]`\n(a source `######` with a positive offset stays at `<h6>` rather than\noverflowing past the HTML heading levels; the floor at `1` is\ndefensive, since this property is meant to be additive-only). `0`\n(the default) preserves today's exact `<h${token.depth}>` output.",
+              "attribute": "heading-offset"
+            },
+            {
+              "kind": "field",
+              "name": "headingTree",
+              "type": {
+                "text": "MarkdownHeadingItem[]"
+              },
+              "privacy": "private",
+              "default": "[]",
+              "description": "Document-ordered heading outline computed on every parse (see `getHeadingTree()`), regardless\nof `headingAnchors`."
+            },
+            {
+              "kind": "field",
+              "name": "highlightCache",
+              "privacy": "private",
+              "default": "new Map<string, string>()",
+              "description": "`(lang, code)` -> already-highlighted HTML, content-addressed (see `PendingHighlight`'s doc).\nPersists across renders of this instance; populated asynchronously by `highlightPending()`.\nNever consulted while `streaming` is `true` or `highlightCode` is `false` -- both gates live\nin the `code()` renderer inside `parseMarkdown()`. Bounded to HIGHLIGHT_CACHE_MAX\nentries, least-recently-used first out, via `getCachedHighlight()`/`setCachedHighlight()` --\nalways go through those instead of the map directly so hits refresh recency."
+            },
+            {
+              "kind": "field",
+              "name": "highlightCode",
+              "type": {
+                "text": "boolean"
+              },
+              "default": "true",
+              "description": "Syntax-highlights fenced code blocks via the same optional `shiki` peer `<lyra-code-block>`\nuses. `true` (the default) upgrades every fenced block from plain `<pre><code>` once the peer\nis available -- a pure upgrade, not a behavior change gated on opt-in, since it's itself gated\ntransparently by whether `shiki` is installed at all (an app that never installs it sees\nbyte-identical output to today). Set `false` to keep plain output even when `shiki` is\ninstalled. No effect while `streaming` is `true` -- see that property's own doc.",
+              "attribute": "highlight-code"
+            },
+            {
+              "kind": "field",
+              "name": "highlightHandle",
+              "type": {
+                "text": "HighlightHandle | undefined"
+              },
+              "privacy": "private",
+              "description": "Lazily acquired the first time a highlight needs painting; released on disconnect."
+            },
+            {
+              "kind": "field",
+              "name": "highlightToken",
+              "type": {
+                "text": "number"
+              },
+              "privacy": "private",
+              "default": "0",
+              "description": "Bumped on every `highlightPending()` call, including ones that end up not actually loading\nanything -- guards against a newer `content`/`streaming` change superseding an older in-flight\nhighlight, exactly mirroring `<lyra-code-block>`'s own `highlightToken` field for the identical\nrace (an async grammar load resolving after a newer call already produced correct output)."
+            },
+            {
+              "kind": "field",
+              "name": "internalLinkPrefix",
+              "type": {
+                "text": "string"
+              },
+              "default": "''",
+              "description": "When set, a rendered link whose `href` starts with this prefix is\ntreated as internal — its click is intercepted and reported via\n`lyra-link-click` instead of navigating. Empty (the default) means\nevery link is treated as external.",
+              "attribute": "internal-link-prefix"
+            },
+            {
+              "kind": "field",
+              "name": "languages",
+              "type": {
+                "text": "Record<string, ShikiLanguageInput>"
+              },
+              "default": "{}",
+              "description": "Grammar definitions this instance can highlight, e.g. `{ json: jsonGrammar }` (import from\n`shiki/langs/<name>.mjs`), forwarded verbatim to `loadShikiHighlighterCore()` -- same shape as\n`<lyra-code-block-core>`'s own `languages`. This component has no default/full-table\nhighlighter to fall back to -- a fenced block whose language isn't a key here always renders\nthe plain-text fallback. Empty (the default) never highlights anything."
+            },
+            {
+              "kind": "field",
+              "name": "linkTarget",
+              "type": {
+                "text": "string | null"
+              },
+              "default": "'_blank'",
+              "description": "`target` applied to every rendered `<a>`, with `rel=\"noopener\nnoreferrer\"` always added alongside it whenever a `target` is emitted.\n`'_blank'` (the default) preserves today's exact output. Set to `null`\n(or the empty string, e.g. via the `link-target=\"\"` attribute) to omit\n`target`/`rel` entirely, so rendered links open in the same tab.",
+              "attribute": "link-target"
+            },
+            {
+              "kind": "field",
+              "name": "loadSchedulePending",
+              "type": {
+                "text": "boolean"
+              },
+              "privacy": "private",
+              "default": "false",
+              "inheritedFrom": {
+                "name": "LyraElement",
+                "module": "src/internal/lyra-element.ts"
+              }
+            },
+            {
+              "kind": "field",
+              "name": "locale",
+              "type": {
+                "text": "string"
+              },
+              "default": "''",
+              "description": "Optional locale override. Otherwise the nearest `locale`/`lang` ancestor is used.",
+              "attribute": "locale",
+              "reflects": true,
+              "inheritedFrom": {
+                "name": "LyraElement",
+                "module": "src/internal/lyra-element.ts"
+              }
+            },
+            {
+              "kind": "field",
+              "name": "math",
+              "type": {
+                "text": "boolean"
+              },
+              "default": "false",
+              "description": "Renders `$...$`/`$$...$$` TeX via the optional `katex` peer, as MathML. `false` (the\ndefault) renders `$...$` literally, unparsed -- today's exact output.",
+              "attribute": "math"
+            },
+            {
+              "kind": "field",
+              "name": "mathFailureReported",
+              "type": {
+                "text": "boolean"
+              },
+              "privacy": "private",
+              "default": "false",
+              "description": "Guards `lyra-render-error` so a permanently-missing `katex` peer reports once per instance,\nnot on every subsequent re-render while `math` stays on. Reset whenever `math` toggles."
+            },
+            {
+              "kind": "field",
+              "name": "onContentClick",
+              "privacy": "private"
+            },
+            {
+              "kind": "field",
+              "name": "pendingLoadController",
+              "type": {
+                "text": "AbortController | undefined"
+              },
+              "privacy": "private",
+              "inheritedFrom": {
+                "name": "LyraElement",
+                "module": "src/internal/lyra-element.ts"
+              }
+            },
+            {
+              "kind": "field",
+              "name": "renderedHtml",
+              "type": {
+                "text": "string | null"
+              },
+              "privacy": "private",
+              "default": "null"
+            },
+            {
+              "kind": "field",
+              "name": "resolvedHighlightRanges",
+              "type": {
+                "text": "{ id: string; range: Range }[]"
+              },
+              "privacy": "private",
+              "default": "[]",
+              "description": "The most recently resolved `text-quote` highlight ranges, kept for `onContentClick()`'s\ncoordinate hit-test -- the CSS Custom Highlight API paints ranges without creating any DOM\nelement to attach a click listener to, so activation is resolved by comparing the click point\nagainst each range's own `getClientRects()` instead, uniformly across both paint paths."
+            },
+            {
+              "kind": "field",
+              "name": "sanitize",
+              "type": {
+                "text": "boolean"
+              },
+              "default": "true",
+              "description": "Sanitize marked's HTML output with DOMPurify before rendering. See the\nclass doc for what happens when this is `true` (the default) but the\n`dompurify` peer isn't installed.",
+              "attribute": "sanitize"
+            },
+            {
+              "kind": "field",
+              "name": "stopLocaleSubscription",
+              "type": {
+                "text": "() => void | undefined"
+              },
+              "privacy": "private",
+              "inheritedFrom": {
+                "name": "LyraElement",
+                "module": "src/internal/lyra-element.ts"
+              }
+            },
+            {
+              "kind": "field",
+              "name": "streaming",
+              "type": {
+                "text": "boolean"
+              },
+              "default": "false",
+              "description": "Signals that `content` is still arriving incrementally. Content changes\ncontinue to render immediately; while this is `true`, the host remains\n`aria-busy=\"true\"` so assistive technology knows the rendered document\nis not final. Set it back to `false` with the final content update.\nReflects so a consumer can also target `lyra-markdown[streaming]`.",
+              "attribute": "streaming",
+              "reflects": true
+            },
+            {
+              "kind": "field",
+              "name": "strings",
+              "type": {
+                "text": "LyraLocaleStrings"
+              },
+              "default": "{}",
+              "description": "Per-instance message overrides, useful for application-specific wording.",
+              "inheritedFrom": {
+                "name": "LyraElement",
+                "module": "src/internal/lyra-element.ts"
+              }
+            },
+            {
+              "kind": "method",
+              "name": "addEventListener",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              },
+              "parameters": [
+                {
+                  "name": "type",
+                  "type": {
+                    "text": "K"
+                  }
+                },
+                {
+                  "name": "listener",
+                  "type": {
+                    "text": "(this: this, event: Events[K]) => unknown"
+                  }
+                },
+                {
+                  "name": "options",
+                  "optional": true,
+                  "type": {
+                    "text": "boolean | AddEventListenerOptions"
+                  }
+                }
+              ],
+              "inheritedFrom": {
+                "name": "LyraElement",
+                "module": "src/internal/lyra-element.ts"
+              }
+            },
+            {
+              "kind": "method",
+              "name": "applyAnchor",
+              "privacy": "protected",
+              "return": {
+                "type": {
+                  "text": "Promise<boolean>"
+                }
+              },
+              "parameters": [
+                {
+                  "name": "anchor",
+                  "type": {
+                    "text": "LyraAnchor"
+                  }
+                }
+              ]
+            },
+            {
+              "kind": "method",
+              "name": "applyFallback",
+              "privacy": "private",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              },
+              "parameters": [
+                {
+                  "name": "error",
+                  "type": {
+                    "text": "unknown"
+                  }
+                }
+              ]
+            },
+            {
+              "kind": "method",
+              "name": "applyFragmentAnchor",
+              "privacy": "private",
+              "return": {
+                "type": {
+                  "text": "boolean"
+                }
+              },
+              "parameters": [
+                {
+                  "name": "root",
+                  "type": {
+                    "text": "Element"
+                  }
+                },
+                {
+                  "name": "anchor",
+                  "type": {
+                    "text": "Extract<LyraAnchor, { kind: 'fragment' }>"
+                  }
+                }
+              ]
+            },
+            {
+              "kind": "method",
+              "name": "applyTextQuoteAnchor",
+              "privacy": "private",
+              "return": {
+                "type": {
+                  "text": "boolean"
+                }
+              },
+              "parameters": [
+                {
+                  "name": "root",
+                  "type": {
+                    "text": "Element"
+                  }
+                },
+                {
+                  "name": "anchor",
+                  "type": {
+                    "text": "Extract<LyraAnchor, { kind: 'text-quote' }>"
+                  }
+                }
+              ]
+            },
+            {
+              "kind": "method",
+              "name": "beginAbortableLoad",
+              "privacy": "protected",
+              "return": {
+                "type": {
+                  "text": "AbortSignal | undefined"
+                }
+              },
+              "description": "Starts a component-owned cancellable load and aborts the previous one.",
+              "inheritedFrom": {
+                "name": "LyraElement",
+                "module": "src/internal/lyra-element.ts"
+              }
+            },
+            {
+              "kind": "method",
+              "name": "computeSelectionAnchor",
+              "privacy": "protected",
+              "return": {
+                "type": {
+                  "text": "LyraAnchor | null"
+                }
+              },
+              "parameters": [
+                {
+                  "name": "range",
+                  "type": {
+                    "text": "Range"
+                  }
+                }
+              ],
+              "description": "Overrides `DocumentAnchorTarget`'s default (whole render-root) selection scope, matching\n`heading`'s slug computation and `applyTextQuoteAnchor()` above: only `[part=\"content\"]` is a\nmeaningful text-quote scope, so a selection that somehow reaches outside it (there is no other\ntext in this component's shadow tree today, but the live region could grow one) never leaks\ninto a captured anchor."
+            },
+            {
+              "kind": "method",
+              "name": "contentRoot",
+              "privacy": "private",
+              "return": {
+                "type": {
+                  "text": "Element | null"
+                }
+              }
+            },
+            {
+              "kind": "method",
+              "name": "emit",
+              "privacy": "protected",
+              "return": {
+                "type": {
+                  "text": "CustomEvent<T>"
+                }
+              },
+              "parameters": [
+                {
+                  "name": "name",
+                  "type": {
+                    "text": "string"
+                  }
+                },
+                {
+                  "name": "detail",
+                  "optional": true,
+                  "type": {
+                    "text": "T"
+                  }
+                },
+                {
+                  "name": "options",
+                  "optional": true,
+                  "type": {
+                    "text": "LyraEmitOptions"
+                  }
+                }
+              ],
+              "description": "Dispatch a composed, bubbling custom event; notifications are not veto points by default.",
+              "inheritedFrom": {
+                "name": "LyraElement",
+                "module": "src/internal/lyra-element.ts"
+              }
+            },
+            {
+              "kind": "method",
+              "name": "ensureHighlightHandle",
+              "privacy": "private",
+              "return": {
+                "type": {
+                  "text": "HighlightHandle"
+                }
+              }
+            },
+            {
+              "kind": "method",
+              "name": "findHeadingByComputedId",
+              "privacy": "private",
+              "return": {
+                "type": {
+                  "text": "Element | null"
+                }
+              },
+              "parameters": [
+                {
+                  "name": "root",
+                  "type": {
+                    "text": "Element"
+                  }
+                },
+                {
+                  "name": "id",
+                  "type": {
+                    "text": "string"
+                  }
+                }
+              ],
+              "description": "`headingAnchors` may be off, so a target heading might carry no `id` attribute in the DOM --\nre-derives the same slug order `getHeadingTree()` was built in and matches by position\ninstead of by attribute."
+            },
+            {
+              "kind": "method",
+              "name": "getCachedHighlight",
+              "privacy": "private",
+              "return": {
+                "type": {
+                  "text": "string | undefined"
+                }
+              },
+              "parameters": [
+                {
+                  "name": "key",
+                  "type": {
+                    "text": "string"
+                  }
+                }
+              ],
+              "description": "LRU read: a hit is re-inserted so Map iteration order (insertion order) keeps the first key\nthe least recently used one -- the entry `setCachedHighlight()` evicts when full."
+            },
+            {
+              "kind": "method",
+              "name": "getHeadingTree",
+              "return": {
+                "type": {
+                  "text": "MarkdownHeadingItem[]"
+                }
+              },
+              "description": "A document-ordered, flattened heading outline -- computed on every parse regardless of\n`headingAnchors` (see that property's own doc). A caller building a table of contents can rely\non this even while `heading-anchors` is off."
+            },
+            {
+              "kind": "method",
+              "name": "highlightPending",
+              "privacy": "private",
+              "return": {
+                "type": {
+                  "text": "Promise<void>"
+                }
+              },
+              "parameters": [
+                {
+                  "name": "pendingKeys",
+                  "type": {
+                    "text": "PendingHighlight[]"
+                  }
+                }
+              ],
+              "description": "Loads whatever shiki grammars `pendingKeys` need, tokenizes each pending block concurrently,\npopulates `highlightCache` with the results, then triggers one more `renderMarkdown()` pass so\nthe newly-cached entries actually reach the screen. A pending key whose language isn't a key in\n`languages`, or otherwise fails to tokenize, is recorded in `failedHighlightKeys` -- it stays\nuncached, so `code()` keeps emitting its plain fallback for it on every future render, and\n`code()` also stops re-discovering it as pending (see `failedHighlightKeys`'s own doc for why\nthat matters: without it, the `renderMarkdown()` call at the end of this method would\nrediscover the same permanently-uncacheable key as pending on every pass, forever). Does not\nblock or delay any other pending key -- each is tried independently via `Promise.all`."
+            },
+            {
+              "kind": "method",
+              "name": "hitTestHighlightAt",
+              "privacy": "private",
+              "return": {
+                "type": {
+                  "text": "string | null"
+                }
+              },
+              "parameters": [
+                {
+                  "name": "x",
+                  "type": {
+                    "text": "number"
+                  }
+                },
+                {
+                  "name": "y",
+                  "type": {
+                    "text": "number"
+                  }
+                }
+              ],
+              "description": "Hit-tests a click point against every currently-resolved highlight's `getClientRects()`,\ntopmost (last-resolved) first. The CSS Custom Highlight API paints ranges without creating any\nDOM element to attach a click listener to, so this is the only activation path that works\nidentically on both paint paths -- mirrors `<lyra-pdf-viewer>`'s own coordinate-based\n`onPageClick()` hit-test for the same reason (its own painted highlights sit under a text\nlayer that intercepts most pointer events)."
+            },
+            {
+              "kind": "method",
+              "name": "localize",
+              "privacy": "protected",
+              "return": {
+                "type": {
+                  "text": "string"
+                }
+              },
+              "parameters": [
+                {
+                  "name": "key",
+                  "type": {
+                    "text": "string"
+                  }
+                },
+                {
+                  "name": "fallback",
+                  "optional": true,
+                  "type": {
+                    "text": "string"
+                  }
+                },
+                {
+                  "name": "values",
+                  "optional": true,
+                  "type": {
+                    "text": "Record<string, string | number>"
+                  }
+                }
+              ],
+              "description": "Resolve a localized message using this component's overrides and locale.",
+              "inheritedFrom": {
+                "name": "LyraElement",
+                "module": "src/internal/lyra-element.ts"
+              }
+            },
+            {
+              "kind": "method",
+              "name": "maybeHighlightPending",
+              "privacy": "private",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              },
+              "parameters": [
+                {
+                  "name": "pendingKeys",
+                  "type": {
+                    "text": "PendingHighlight[]"
+                  }
+                }
+              ],
+              "description": "Kicks off async highlighting for `pendingKeys` (see `highlightPending()`) unless there's\nnothing to do, `highlightCode` is off, or `streaming` is on -- called from both of\n`renderMarkdown()`'s exit points (the `sanitize=false` early return and the normal sanitized\npath), since highlighting is independent of that decision."
+            },
+            {
+              "kind": "method",
+              "name": "maybeLoadKatex",
+              "privacy": "private",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              },
+              "description": "Kicks off the shared `katex` load the first time `math` needs it and no attempt is already\nin flight (module-scoped, so every `<lyra-markdown>` instance on the page shares one load --\nmirrors `markdown-loader.ts`'s own warm-cache shape). Skipped entirely under\n`__setKatexForTesting()` -- that seam controls math-rendering behavior directly and must never\nrace a real, unmocked `import('katex')` settling underneath it."
+            },
+            {
+              "kind": "method",
+              "name": "parseMarkdown",
+              "privacy": "private",
+              "return": {
+                "type": {
+                  "text": "{ html: string; hadMathFallback: boolean }"
+                }
+              },
+              "parameters": [
+                {
+                  "name": "marked",
+                  "type": {
+                    "text": "OptionalPeerApi"
+                  }
+                },
+                {
+                  "name": "pendingKeys",
+                  "type": {
+                    "text": "PendingHighlight[]"
+                  }
+                },
+                {
+                  "name": "headingTreeOut",
+                  "type": {
+                    "text": "MarkdownHeadingItem[]"
+                  }
+                }
+              ]
+            },
+            {
+              "kind": "method",
+              "name": "removeEventListener",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              },
+              "parameters": [
+                {
+                  "name": "type",
+                  "type": {
+                    "text": "K"
+                  }
+                },
+                {
+                  "name": "listener",
+                  "type": {
+                    "text": "(this: this, event: Events[K]) => unknown"
+                  }
+                },
+                {
+                  "name": "options",
+                  "optional": true,
+                  "type": {
+                    "text": "boolean | EventListenerOptions"
+                  }
+                }
+              ],
+              "inheritedFrom": {
+                "name": "LyraElement",
+                "module": "src/internal/lyra-element.ts"
+              }
+            },
+            {
+              "kind": "method",
+              "name": "renderMarkdown",
+              "privacy": "private",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              }
+            },
+            {
+              "kind": "method",
+              "name": "repaintHighlights",
+              "privacy": "private",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              },
+              "description": "Re-resolves every `text-quote` highlight against the current rendered content and repaints\nvia `acquireHighlightHandle()` -- resolution is always by quote text, never by node identity,\nso a highlight set before its quote exists in `content` yet (e.g. mid-`streaming`) simply\npaints nothing until a later render's text actually contains it. `fragment` highlights aren't\npainted (there is no literal span of text to wrap/underline for a whole section)."
+            },
+            {
+              "kind": "method",
+              "name": "reportMathFailure",
+              "privacy": "private",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              },
+              "description": "Fires `lyra-render-error` once per instance for a permanently-missing `katex` peer. Called\nonly once `renderMarkdown()` has confirmed the peer is actually missing (`katexOverride` or\nthe resolved module is `null`) -- a math token rendering its literal fallback while the load\nis merely still in flight (the same one-microtask transient window every other optional peer\nin this component has) never reports an error on its own."
+            },
+            {
+              "kind": "method",
+              "name": "scheduleAfterUpdate",
+              "privacy": "protected",
+              "return": {
+                "type": {
+                  "text": "void"
+                }
+              },
+              "parameters": [
+                {
+                  "name": "callback",
+                  "type": {
+                    "text": "() => void"
+                  }
+                }
+              ],
+              "description": "Runs one coalesced load callback after the current update completes.\nLit still runs the update cycle while detached, so a load scheduled then is\nheld and replayed on reconnect rather than dropped.",
+              "inheritedFrom": {
+                "name": "LyraElement",
+                "module": "src/internal/lyra-element.ts"
+              }
+            },
+            {
+              "kind": "method",
+              "name": "setCachedHighlight",
               "privacy": "private",
               "return": {
                 "type": {
                   "text": "void"
                 }
               },
-              "description": "Constructs the underlying `maplibregl.Map` — called once both the\nlazy-loaded `maplibre-gl` module has resolved and this element has been\nobserved intersecting the viewport, whichever settles last. Idempotent\n(a no-op once `_map` already exists), so it's safe to call from both the\n`connectedCallback()` load path and the visibility path in `updated()`\nbelow without risking a double construction."
+              "parameters": [
+                {
+                  "name": "key",
+                  "type": {
+                    "text": "string"
+                  }
+                },
+                {
+                  "name": "html",
+                  "type": {
+                    "text": "string"
+                  }
+                }
+              ]
             }
           ],
           "events": [
             {
-              "description": "`detail: { lngLat, feature? }`.",
-              "name": "lyra-map-click"
+              "description": "Fired after an `anchor` property assignment or a `scrollToAnchor()` call is applied. `detail: { found }`.",
+              "name": "lyra-anchor-result"
             },
             {
-              "description": "Fired once the underlying maplibregl.Map loads.",
-              "name": "lyra-map-load"
+              "description": "A painted `text-quote` highlight was clicked. `detail: { id }`.",
+              "name": "lyra-highlight-activate"
+            },
+            {
+              "description": "Fired (and the click prevented) when a rendered link's `href` starts with `internal-link-prefix`. `detail: { href: string, internal: true }`. Ordinary external links navigate normally (in `link-target`) and never fire this event.",
+              "name": "lyra-link-click"
+            },
+            {
+              "description": "Fired whenever rendering falls back to plain text, or `math` is set but the `katex` peer isn't installed. `detail: { error: unknown }`.",
+              "name": "lyra-render-error"
+            },
+            {
+              "description": "Fired on selection end inside the rendered content. `detail: { text, anchor, rects }`; `anchor` is a `text-quote` `LyraAnchor` scoped to the rendered content, or `null` if the selection couldn't be anchored.",
+              "name": "lyra-text-select"
             }
           ],
           "attributes": [
             {
-              "name": "center",
+              "name": "content",
               "type": {
-                "text": "[number, number]"
+                "text": "string"
               },
-              "default": "[0, 0]",
-              "fieldName": "center"
+              "default": "''",
+              "description": "The Markdown source to render.",
+              "fieldName": "content"
             },
             {
-              "name": "label",
+              "name": "eager-load",
+              "type": {
+                "text": "boolean"
+              },
+              "default": "false",
+              "description": "When `true`, `connectedCallback()` skips awaiting `loadMarkdownDeps()`'s\ndynamic `import()` if the shared `marked`/`dompurify` module cache (see\n`markdown-loader.ts`'s `getMarkdownDepsIfLoaded()`) has *already*\nresolved — e.g. because an earlier `<lyra-markdown>` instance on the\npage already finished loading, or the consumer primed the cache\ndirectly by calling `loadMarkdownDeps()` themselves at startup — and\nrenders synchronously instead. When the cache isn't warm yet (most\nnotably: the very first `<lyra-markdown>` ever connected on a page,\nsince nothing has called `loadMarkdownDeps()` before it), this still\nfalls back to the normal async path — a dynamic `import()` can't be\nmade synchronous, so this is a fast path for the common \"already warm\"\ncase, not a hard guarantee. `false` (the default) is byte-identical to\ntoday: always the async `import()`, fallback-text window included.",
+              "fieldName": "eagerLoad"
+            },
+            {
+              "name": "escape-html",
+              "type": {
+                "text": "boolean"
+              },
+              "default": "false",
+              "description": "When `true`, overrides marked's `html` renderer hook to emit the HTML-escaped source text\ninstead of passing raw/sanitized markup through -- for a consumer rendering arbitrary\nalready-written content (e.g. a historical chat/agent transcript full of code/XML/HTML\nsnippets) where a stray angle bracket should render as visible text, not a real DOM element.\nStill lets GFM tables/lists/etc. render normally -- only raw embedded HTML is affected.\n`false` (the default) reproduces today's exact `marked`-default (sanitized-when-`sanitize`)\npassthrough behavior.",
+              "fieldName": "escapeHtml"
+            },
+            {
+              "name": "gfm",
+              "type": {
+                "text": "boolean"
+              },
+              "default": "true",
+              "description": "Enable GitHub-flavored Markdown (tables, strikethrough, autolinks, task lists).",
+              "fieldName": "gfm"
+            },
+            {
+              "name": "heading-anchors",
+              "type": {
+                "text": "boolean"
+              },
+              "default": "false",
+              "description": "Stamps a computed slug as `id` on every rendered heading. `getHeadingTree()` computes the\nsame slugs regardless of this property -- it only controls whether the `id` attribute is\nemitted into the rendered DOM. `false` (the default) preserves today's exact output.\n\nWhen `sanitize` is also on (the default), a slug whose *value* collides with a real\n`document` property name (e.g. a heading literally titled \"Title\", \"Location\", or \"Forms\"\nslugs to `title`/`location`/`forms`) has its `id` silently stripped by DOMPurify's DOM-\nclobbering protection (`SANITIZE_DOM`) -- `getHeadingTree()` still reports that heading's slug\neither way, but `scrollToAnchor({ kind: 'fragment', id })` still resolves it correctly even\nwithout a DOM `id` present, via its own position-based fallback lookup.",
+              "fieldName": "headingAnchors"
+            },
+            {
+              "name": "heading-offset",
+              "type": {
+                "text": "number"
+              },
+              "default": "0",
+              "description": "Added to every rendered heading's source `token.depth` before emitting\n`<h${depth}>` — e.g. `heading-offset=\"2\"` renders a source `#` as\n`<h3>` and a source `##` as `<h4>`. The result is clamped to `[1, 6]`\n(a source `######` with a positive offset stays at `<h6>` rather than\noverflowing past the HTML heading levels; the floor at `1` is\ndefensive, since this property is meant to be additive-only). `0`\n(the default) preserves today's exact `<h${token.depth}>` output.",
+              "fieldName": "headingOffset"
+            },
+            {
+              "name": "highlight-code",
+              "type": {
+                "text": "boolean"
+              },
+              "default": "true",
+              "description": "Syntax-highlights fenced code blocks via the same optional `shiki` peer `<lyra-code-block>`\nuses. `true` (the default) upgrades every fenced block from plain `<pre><code>` once the peer\nis available -- a pure upgrade, not a behavior change gated on opt-in, since it's itself gated\ntransparently by whether `shiki` is installed at all (an app that never installs it sees\nbyte-identical output to today). Set `false` to keep plain output even when `shiki` is\ninstalled. No effect while `streaming` is `true` -- see that property's own doc.",
+              "fieldName": "highlightCode"
+            },
+            {
+              "name": "internal-link-prefix",
               "type": {
                 "text": "string"
               },
               "default": "''",
-              "description": "Accessible name fallback for the map group. A host `aria-label` takes\nprecedence when both are set; when neither is present, the group uses\nthe localized `map` message.",
-              "fieldName": "label"
+              "description": "When set, a rendered link whose `href` starts with this prefix is\ntreated as internal — its click is intercepted and reported via\n`lyra-link-click` instead of navigating. Empty (the default) means\nevery link is treated as external.",
+              "fieldName": "internalLinkPrefix"
+            },
+            {
+              "name": "link-target",
+              "type": {
+                "text": "string | null"
+              },
+              "default": "'_blank'",
+              "description": "`target` applied to every rendered `<a>`, with `rel=\"noopener\nnoreferrer\"` always added alongside it whenever a `target` is emitted.\n`'_blank'` (the default) preserves today's exact output. Set to `null`\n(or the empty string, e.g. via the `link-target=\"\"` attribute) to omit\n`target`/`rel` entirely, so rendered links open in the same tab.",
+              "fieldName": "linkTarget"
             },
             {
               "name": "locale",
@@ -98773,44 +99961,69 @@
               }
             },
             {
-              "name": "zoom",
+              "name": "math",
               "type": {
-                "text": "number"
+                "text": "boolean"
               },
-              "default": "2",
-              "fieldName": "zoom"
+              "default": "false",
+              "description": "Renders `$...$`/`$$...$$` TeX via the optional `katex` peer, as MathML. `false` (the\ndefault) renders `$...$` literally, unparsed -- today's exact output.",
+              "fieldName": "math"
+            },
+            {
+              "name": "sanitize",
+              "type": {
+                "text": "boolean"
+              },
+              "default": "true",
+              "description": "Sanitize marked's HTML output with DOMPurify before rendering. See the\nclass doc for what happens when this is `true` (the default) but the\n`dompurify` peer isn't installed.",
+              "fieldName": "sanitize"
+            },
+            {
+              "name": "streaming",
+              "type": {
+                "text": "boolean"
+              },
+              "default": "false",
+              "description": "Signals that `content` is still arriving incrementally. Content changes\ncontinue to render immediately; while this is `true`, the host remains\n`aria-busy=\"true\"` so assistive technology knows the rendered document\nis not final. Set it back to `false` with the final content update.\nReflects so a consumer can also target `lyra-markdown[streaming]`.",
+              "fieldName": "streaming"
+            }
+          ],
+          "mixins": [
+            {
+              "name": "DocumentAnchorTarget",
+              "module": "/src/internal/anchor-target.js"
             }
           ],
           "superclass": {
-            "name": "LyraElement",
-            "module": "/src/internal/lyra-element.js"
+            "name": "LyraMarkdownCoreBase",
+            "module": "src/components/markdown/markdown-core.class.ts"
           },
-          "tagName": "lyra-map",
+          "tagName": "lyra-markdown-core",
           "customElement": true
         }
       ],
       "exports": [
         {
           "kind": "js",
-          "name": "LyraMap",
+          "name": "LyraMarkdownCore",
           "declaration": {
-            "name": "LyraMap",
-            "module": "src/components/map/map.class.ts"
+            "name": "LyraMarkdownCore",
+            "module": "src/components/markdown/markdown-core.class.ts"
           }
         }
       ]
     },
     {
       "kind": "javascript-module",
-      "path": "src/components/map/map.ts",
+      "path": "src/components/markdown/markdown-core.ts",
       "declarations": [],
       "exports": [
         {
           "kind": "custom-element-definition",
-          "name": "lyra-map",
+          "name": "lyra-markdown-core",
           "declaration": {
-            "name": "LyraMap",
-            "module": "src/components/map/map.class.ts"
+            "name": "LyraMarkdownCore",
+            "module": "src/components/markdown/markdown-core.class.ts"
           }
         },
         {
@@ -98818,69 +100031,7 @@
           "name": "*",
           "declaration": {
             "name": "*",
-            "module": "src/components/map/map.class.js"
-          }
-        }
-      ]
-    },
-    {
-      "kind": "javascript-module",
-      "path": "src/components/markdown/katex-loader.ts",
-      "declarations": [
-        {
-          "kind": "function",
-          "name": "getKatex",
-          "return": {
-            "type": {
-              "text": "Promise<KatexApi | null>"
-            }
-          },
-          "parameters": [
-            {
-              "name": "importKatex",
-              "optional": true,
-              "type": {
-                "text": "() => Promise<{ default: KatexApi } | KatexApi>"
-              }
-            }
-          ],
-          "description": "Lazily loads `katex` once per page, caching the resolved module (or `null`) across every\n`<lyra-markdown>` instance -- mirrors `markdown-loader.ts`'s `loadMarkdownDeps()`/\n`getMarkdownDepsIfLoaded()` cached-promise shape for a single optional peer."
-        },
-        {
-          "kind": "function",
-          "name": "loadKatex",
-          "return": {
-            "type": {
-              "text": "Promise<KatexApi | null>"
-            }
-          },
-          "parameters": [
-            {
-              "name": "importKatex",
-              "default": "() =>\n    import('katex') as Promise<{ default: KatexApi }>",
-              "type": {
-                "text": "() => Promise<{ default: KatexApi } | KatexApi>"
-              }
-            }
-          ],
-          "description": "Loads the optional peer dependency `katex`, used by `<lyra-markdown>`'s `math` property to\nrender `$...$`/`$$...$$` TeX as MathML. Resolves `null` (with a one-time `console.warn`) if the\npeer isn't installed -- rendering falls back to the literal, unparsed TeX source in that case,\na fully supported default rather than a degraded mode. Mirrors `dompurify-loader.ts`'s single-\noptional-peer shape."
-        }
-      ],
-      "exports": [
-        {
-          "kind": "js",
-          "name": "getKatex",
-          "declaration": {
-            "name": "getKatex",
-            "module": "src/components/markdown/katex-loader.ts"
-          }
-        },
-        {
-          "kind": "js",
-          "name": "loadKatex",
-          "declaration": {
-            "name": "loadKatex",
-            "module": "src/components/markdown/katex-loader.ts"
+            "module": "src/components/markdown/markdown-core.class.js"
           }
         }
       ]
@@ -148768,7 +149919,7 @@
       "declarations": [
         {
           "kind": "class",
-          "description": "`<lyra-thread-list>` — the conversation sidebar: a grouped, searchable list of chat sessions with\npin/archive/delete/rename affordances. *Data mode* (non-empty `threads`, or empty `threads` with\nnothing slotted) renders every row as a `<lyra-conversation-item>` inside an internal\n`<lyra-virtual-list>` — virtualized by construction, scroll position and per-row state survive a\n`threads` replacement; zero rows renders the built-in empty state. *Slotted mode* (empty `threads`\n*and* real slotted content) renders host-supplied `<lyra-conversation-item>`s from the default slot\nas-is: no grouping, virtualization, or row actions in that mode — those are data-mode-only by design\n(shadow DOM cannot inject group headers between slotted children).\n\nNo thread CRUD or persistence: every mutation (`lyra-thread-pin`/`-archive`/`-delete`/`-rename`) is\na controlled event carrying the *requested* new state — the host mutates `threads`.",
+          "description": "`<lyra-thread-list>` — the conversation sidebar: a grouped, searchable list of chat sessions with\npin/archive/delete/rename affordances. *Data mode* (non-empty `threads`, or empty `threads` with\nnothing slotted) renders every row as a `<lyra-conversation-item>` inside an internal\n`<lyra-virtual-list>` — virtualized by construction, scroll position and per-row state survive a\n`threads` replacement; zero rows renders the built-in empty state. *Slotted mode* (empty `threads`\n*and* real slotted content) renders host-supplied `<lyra-conversation-item>`s from the default slot\nas-is: no grouping, virtualization, or row actions in that mode — those are data-mode-only by design\n(shadow DOM cannot inject group headers between slotted children).\n\nNo thread CRUD or persistence: every mutation (`lyra-thread-pin`/`-archive`/`-delete`/`-rename`) is\na controlled event carrying the *requested* new state — the host mutates `threads`.\n\nData mode: a host needing content with no home in `lyra-conversation-item`'s own\n`title`/`excerpt`/`meta`/`actions` surface (e.g. a leading purpose icon — the item has no default\nslot to receive one) sets `wrapRow` to wrap the already-built row.",
           "name": "LyraThreadList",
           "cssParts": [
             {
@@ -149110,6 +150261,14 @@
               "privacy": "private",
               "readonly": true
             },
+            {
+              "kind": "field",
+              "name": "wrapRow",
+              "type": {
+                "text": "(thread: ChatThread, row: TemplateResult) => TemplateResult | undefined"
+              },
+              "description": "Data mode only: wraps each row's built-in `<lyra-conversation-item>` with host-supplied\ncontent that has no home in the item's own `title`/`excerpt`/`meta`/`actions` surface — e.g. a\nleading purpose icon (`lyra-conversation-item` has no default slot to receive one) or trailing\ntag chips. Receives the thread and the already-built row `TemplateResult`; returns the final\nrow content. Unset renders the built-in row unwrapped."
+            },
             {
               "kind": "method",
               "name": "addEventListener",
@@ -162082,7 +163241,7 @@
       "declarations": [
         {
           "kind": "class",
-          "description": "`<lyra-usage-badge>` — a compact, static resource strip for one message or run: tokens in/out,\ncost, latency, with a hover/focus tooltip breakdown. Purely formatting — this component computes\nno counts, rates, or prices; every segment is independently optional, and with nothing set,\nnothing renders at all (not even a focusable/interactive shell).\n\nThe tooltip reuses `<lyra-tool-call-chip>`'s hover/focus/Escape/`aria-describedby` contract\nwholesale: hover and focus are tracked as independent \"keep it open\" reasons, so releasing one\nmodality while the other still holds doesn't close it.",
+          "description": "`<lyra-usage-badge>` — a compact, static resource strip for one message or run: tokens in/out,\ncost, latency, with a hover/focus tooltip breakdown. Purely formatting — this component computes\nno counts, rates, or prices; every segment is independently optional, and with nothing set,\nnothing renders at all (not even a focusable/interactive shell).\n\nThe tooltip reuses `<lyra-tool-call-chip>`'s hover/focus/Escape/`aria-describedby` contract\nwholesale: hover and focus are tracked as independent \"keep it open\" reasons, so releasing one\nmodality while the other still holds doesn't close it.\n\nThe built-in latency formatting has no minutes/hours tier (`'{ms}ms'`, or one-decimal seconds\nabove 1000ms) — a host whose latencies commonly exceed a minute sets `formatLatency` to render\nits own scale instead, in both the visible strip and the tooltip row.",
           "name": "LyraUsageBadge",
           "cssParts": [
             {
@@ -162194,6 +163353,14 @@
               "privacy": "private",
               "default": "false"
             },
+            {
+              "kind": "field",
+              "name": "formatLatency",
+              "type": {
+                "text": "(ms: number) => string | undefined"
+              },
+              "description": "Overrides the default `formatDuration()` rendering of `latencyMs` (`'{ms}ms'`, or one-decimal\nseconds above 1000ms — no minutes/hours tier) in both the visible strip and the tooltip row.\nMirrors `<lyra-activity-feed>`'s `formatTimestamp` convention."
+            },
             {
               "kind": "field",
               "name": "hasCost",
@@ -162272,7 +163439,7 @@
               "type": {
                 "text": "number | undefined"
               },
-              "description": "Latency in milliseconds, formatted with the shared duration algorithm.",
+              "description": "Latency in milliseconds, formatted with the shared duration algorithm (or `formatLatency`,\nwhen set).",
               "attribute": "latency-ms"
             },
             {
@@ -162692,7 +163859,7 @@
               "type": {
                 "text": "number | undefined"
               },
-              "description": "Latency in milliseconds, formatted with the shared duration algorithm.",
+              "description": "Latency in milliseconds, formatted with the shared duration algorithm (or `formatLatency`,\nwhen set).",
               "fieldName": "latencyMs"
             },
             {