@aceshooting/lyra-ui 3.9.0 → 4.1.0

package/dist/components/markdown/markdown.class.d.ts

@@ -11,10 +11,10 @@ export interface MarkdownHeadingItem {
     level: number;
 }
 export interface LyraMarkdownEventMap extends LyraAnchorTargetEventMap {
-    'lyra-render-error': CustomEvent<{
+    'lr-render-error': CustomEvent<{
         error: unknown;
     }>;
-    'lyra-link-click': CustomEvent<{
+    'lr-link-click': CustomEvent<{
         href: string;
         internal: boolean;
     }>;
@@ -25,7 +25,7 @@ declare const LyraMarkdown_base: typeof LyraMarkdownBase & (new (...args: any[])
     renderAnchorLiveRegion(): unknown;
 });
 /**
- * `<lyra-markdown>` — sanitized Markdown-to-HTML rendering (GFM tables,
+ * `<lr-markdown>` — sanitized Markdown-to-HTML rendering (GFM tables,
  * fenced code blocks, links, blockquotes) built on the optional peer
  * dependencies `marked` (parsing) and `dompurify` (sanitizing), both
  * lazy-loaded via `markdown-loader.ts` on first connect.
@@ -33,9 +33,9 @@ declare const LyraMarkdown_base: typeof LyraMarkdownBase & (new (...args: any[])
  * Rendering never ships unsanitized or broken markup silently:
  * - If `marked` fails to load, or throws while parsing malformed input, the
  *   component falls back to plain text (`white-space: pre-wrap`, no HTML
- *   parsing at all) and fires `lyra-render-error`.
+ *   parsing at all) and fires `lr-render-error`.
  * - If `sanitize` is `true` (the default) and `dompurify` fails to load, the
- *   component *also* falls back to plain text + `lyra-render-error` — it
+ *   component *also* falls back to plain text + `lr-render-error` — it
  *   never renders marked's raw HTML output when sanitization was requested
  *   (or defaulted to) but is unavailable, even though `marked` itself loaded
  *   fine.
@@ -47,7 +47,7 @@ declare const LyraMarkdown_base: typeof LyraMarkdownBase & (new (...args: any[])
  * part) is also, unconditionally and by default, a brief *transient* state on
  * every connect, not just a failure path: `connectedCallback()`'s dynamic
  * `import()` of `marked`/`dompurify` (see `markdown-loader.ts`) is
- * asynchronous, so the very first paint of any `<lyra-markdown>` on a page
+ * asynchronous, so the very first paint of any `<lr-markdown>` on a page
  * shows plain text for at least one microtask — even when both peers are
  * already installed and load without error — until that import resolves and
  * a second render replaces it with the real Markdown output. Set
@@ -59,9 +59,9 @@ declare const LyraMarkdown_base: typeof LyraMarkdownBase & (new (...args: any[])
  * directly into the produced HTML — a single pass, not a second DOM walk
  * after insertion.
  *
- * Fenced code blocks are syntax-highlighted via the same optional `shiki` peer `<lyra-code-block>`
+ * Fenced code blocks are syntax-highlighted via the same optional `shiki` peer `<lr-code-block>`
  * uses (`highlightCode`, default `true` — a pure upgrade gated by whether `shiki` is installed at
- * all, not a separate opt-in). `languages`/`languagesOnly` mirror `<lyra-code-block>`'s own
+ * all, not a separate opt-in). `languages`/`languagesOnly` mirror `<lr-code-block>`'s own
  * fine-grained bundle-size controls. The very first render of any content is always plain
  * (identical to today's output); highlighting arrives as an asynchronous upgrade one render later,
  * once shiki resolves. No highlighting is attempted while `streaming` is `true` — it applies once a
@@ -82,20 +82,20 @@ declare const LyraMarkdown_base: typeof LyraMarkdownBase & (new (...args: any[])
  * `renderToString(tex, { output: 'mathml' })` -- MathML Core renders natively and accessibly in
  * evergreen browsers with no extra stylesheet or webfont needing to cross the shadow boundary. A
  * missing `katex` peer renders the literal, unparsed TeX source (delimiters included) and fires one
- * `lyra-render-error`.
+ * `lr-render-error`.
  *
- * @customElement lyra-markdown
- * @event lyra-link-click - Fired (and the click prevented) when a rendered
+ * @customElement lr-markdown
+ * @event lr-link-click - 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.
- * @event lyra-render-error - Fired whenever rendering falls back to plain
+ * @event lr-render-error - Fired whenever rendering falls back to plain
  *   text, or `math` is set but the `katex` peer isn't installed. `detail: { error: unknown }`.
- * @event lyra-highlight-activate - A painted `text-quote` highlight was clicked. `detail: { id }`.
- * @event lyra-text-select - Fired on selection end inside the rendered content. `detail: { text,
+ * @event lr-highlight-activate - A painted `text-quote` highlight was clicked. `detail: { id }`.
+ * @event lr-text-select - 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.
- * @event lyra-anchor-result - Fired after an `anchor` property assignment or a `scrollToAnchor()`
+ * @event lr-anchor-result - Fired after an `anchor` property assignment or a `scrollToAnchor()`
  *   call is applied. `detail: { found }`.
  * @csspart content - The wrapper around the rendered (or plain-text
  *   fallback) output.
@@ -137,7 +137,7 @@ export declare class LyraMarkdown extends LyraMarkdown_base {
     linkTarget: string | null;
     /** When set, a rendered link whose `href` starts with this prefix is
      *  treated as internal — its click is intercepted and reported via
-     *  `lyra-link-click` instead of navigating. Empty (the default) means
+     *  `lr-link-click` instead of navigating. Empty (the default) means
      *  every link is treated as external. */
     internalLinkPrefix: string;
     /** Added to every rendered heading's source `token.depth` before emitting
@@ -151,11 +151,11 @@ export declare class LyraMarkdown extends LyraMarkdown_base {
     /** When `true`, `connectedCallback()` skips awaiting `loadMarkdownDeps()`'s
      *  dynamic `import()` if the shared `marked`/`dompurify` module cache (see
      *  `markdown-loader.ts`'s `getMarkdownDepsIfLoaded()`) has *already*
-     *  resolved — e.g. because an earlier `<lyra-markdown>` instance on the
+     *  resolved — e.g. because an earlier `<lr-markdown>` instance on the
      *  page already finished loading, or the consumer primed the cache
      *  directly by calling `loadMarkdownDeps()` themselves at startup — and
      *  renders synchronously instead. When the cache isn't warm yet (most
-     *  notably: the very first `<lyra-markdown>` ever connected on a page,
+     *  notably: the very first `<lr-markdown>` ever connected on a page,
      *  since nothing has called `loadMarkdownDeps()` before it), this still
      *  falls back to the normal async path — a dynamic `import()` can't be
      *  made synchronous, so this is a fast path for the common "already warm"
@@ -166,21 +166,21 @@ export declare class LyraMarkdown extends LyraMarkdown_base {
      *  continue to render immediately; while this is `true`, the host remains
      *  `aria-busy="true"` so assistive technology knows the rendered document
      *  is not final. Set it back to `false` with the final content update.
-     *  Reflects so a consumer can also target `lyra-markdown[streaming]`. */
+     *  Reflects so a consumer can also target `lr-markdown[streaming]`. */
     streaming: boolean;
-    /** Syntax-highlights fenced code blocks via the same optional `shiki` peer `<lyra-code-block>`
+    /** Syntax-highlights fenced code blocks via the same optional `shiki` peer `<lr-code-block>`
      *  uses. `true` (the default) upgrades every fenced block from plain `<pre><code>` once the peer
      *  is available -- a pure upgrade, not a behavior change gated on opt-in, since it's itself gated
      *  transparently by whether `shiki` is installed at all (an app that never installs it sees
      *  byte-identical output to today). Set `false` to keep plain output even when `shiki` is
      *  installed. No effect while `streaming` is `true` -- see that property's own doc. */
     highlightCode: boolean;
-    /** Same shape and purpose as `<lyra-code-block>`'s own `languages` -- a fine-grained, explicit
+    /** Same shape and purpose as `<lr-code-block>`'s own `languages` -- a fine-grained, explicit
      *  language-grammar bundle scoping shiki's build output to just those grammars instead of its
      *  full ~200-language bundle. Forwarded verbatim to `loadShikiHighlighterCore()`. Unset uses the
-     *  default full-bundle loader, unchanged from how `<lyra-code-block>` itself defaults. */
+     *  default full-bundle loader, unchanged from how `<lr-code-block>` itself defaults. */
     languages?: Record<string, ShikiLanguageInput>;
-    /** Same purpose as `<lyra-code-block>`'s own `languagesOnly` -- skips the default full-bundle
+    /** Same purpose as `<lr-code-block>`'s own `languagesOnly` -- skips the default full-bundle
      *  loader entirely, so a fenced block whose language isn't in `languages` falls back to plain
      *  unhighlighted text rather than reaching for the full bundle. No effect unless `languages` is
      *  also set. */
@@ -213,7 +213,7 @@ export declare class LyraMarkdown extends LyraMarkdown_base {
      *  element to attach a click listener to, so activation is resolved by comparing the click point
      *  against each range's own `getClientRects()` instead, uniformly across both paint paths. */
     private resolvedHighlightRanges;
-    /** Guards `lyra-render-error` so a permanently-missing `katex` peer reports once per instance,
+    /** Guards `lr-render-error` so a permanently-missing `katex` peer reports once per instance,
      *  not on every subsequent re-render while `math` stays on. Reset whenever `math` toggles. */
     private mathFailureReported;
     /** `(lang, code)` -> already-highlighted HTML, content-addressed (see `PendingHighlight`'s doc).
@@ -229,7 +229,7 @@ export declare class LyraMarkdown extends LyraMarkdown_base {
     private setCachedHighlight;
     /** Bumped on every `highlightPending()` call, including ones that end up not actually loading
      *  anything -- guards against a newer `content`/`streaming` change superseding an older in-flight
-     *  highlight, exactly mirroring `<lyra-code-block>`'s own `highlightToken` field for the identical
+     *  highlight, exactly mirroring `<lr-code-block>`'s own `highlightToken` field for the identical
      *  race (an async grammar load resolving after a newer call already produced correct output). */
     private highlightToken;
     /** Keys from `PendingHighlight` that failed to highlight -- peer missing, language unrecognized,
@@ -239,11 +239,11 @@ export declare class LyraMarkdown extends LyraMarkdown_base {
      *  `highlightPending()` itself triggers on completion -- would rediscover it as pending and retry
      *  it again, forever. Mirrors `code-loader.ts`'s own `unsupportedLanguages` Set, which exists for
      *  the identical reason one level down (a single unrecognized `language` value on
-     *  `<lyra-code-block>`). */
+     *  `<lr-code-block>`). */
     private failedHighlightKeys;
     connectedCallback(): void;
     disconnectedCallback(): void;
-    /** Binds selection -> `lyra-text-select` once, on the stable `[part="content"]` wrapper --
+    /** Binds selection -> `lr-text-select` once, on the stable `[part="content"]` wrapper --
      *  re-renders only replace that wrapper's children via `unsafeHTML`, never the wrapper itself.
      *  `bindTextSelection` is `protected` on the mixin's own narrowed return type (deliberately not
      *  part of `LyraAnchorTarget`'s public surface -- see `anchor-target.ts`'s class doc), so it's
@@ -255,12 +255,12 @@ export declare class LyraMarkdown extends LyraMarkdown_base {
     private renderMarkdown;
     private applyFallback;
     /** Kicks off the shared `katex` load the first time `math` needs it and no attempt is already
-     *  in flight (module-scoped, so every `<lyra-markdown>` instance on the page shares one load --
+     *  in flight (module-scoped, so every `<lr-markdown>` instance on the page shares one load --
      *  mirrors `markdown-loader.ts`'s own warm-cache shape). Skipped entirely under
      *  `__setKatexForTesting()` -- that seam controls math-rendering behavior directly and must never
      *  race a real, unmocked `import('katex')` settling underneath it. */
     private maybeLoadKatex;
-    /** Fires `lyra-render-error` once per instance for a permanently-missing `katex` peer. Called
+    /** Fires `lr-render-error` once per instance for a permanently-missing `katex` peer. Called
      *  only once `renderMarkdown()` has confirmed the peer is actually missing (`katexOverride` or
      *  the resolved module is `null`) -- a math token rendering its literal fallback while the load
      *  is merely still in flight (the same one-microtask transient window every other optional peer
@@ -311,7 +311,7 @@ export declare class LyraMarkdown extends LyraMarkdown_base {
     /** Hit-tests a click point against every currently-resolved highlight's `getClientRects()`,
      *  topmost (last-resolved) first. The CSS Custom Highlight API paints ranges without creating any
      *  DOM element to attach a click listener to, so this is the only activation path that works
-     *  identically on both paint paths -- mirrors `<lyra-pdf-viewer>`'s own coordinate-based
+     *  identically on both paint paths -- mirrors `<lr-pdf-viewer>`'s own coordinate-based
      *  `onPageClick()` hit-test for the same reason (its own painted highlights sit under a text
      *  layer that intercepts most pointer events). */
     private hitTestHighlightAt;
@@ -320,7 +320,7 @@ export declare class LyraMarkdown extends LyraMarkdown_base {
 }
 declare global {
     interface HTMLElementTagNameMap {
-        'lyra-markdown': LyraMarkdown;
+        'lr-markdown': LyraMarkdown;
     }
 }
 export {};

package/dist/components/markdown/markdown.class.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"markdown.class.d.ts","sourceRoot":"","sources":["../../../src/components/markdown/markdown.class.ts"],"names":[],"mappings":"AAAA,OAAO,EAAQ,KAAK,cAAc,EAAE,KAAK,cAAc,EAAE,MAAM,KAAK,CAAC;AAGrE,OAAO,EAAE,WAAW,EAAE,MAAM,gCAAgC,CAAC;AAK7D,OAAO,EAAwB,KAAK,wBAAwB,EAAE,MAAM,iCAAiC,CAAC;AAItG,OAAO,KAAK,EAAE,UAAU,EAAE,cAAc,EAA8C,MAAM,+BAA+B,CAAC;AAE5H,OAAO,EAQL,KAAK,kBAAkB,EACxB,MAAM,8BAA8B,CAAC;AA6CtC;sGACsG;AACtG,MAAM,WAAW,mBAAmB;IAClC,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;CACf;AAuHD,MAAM,WAAW,oBAAqB,SAAQ,wBAAwB;IACpE,mBAAmB,EAAE,WAAW,CAAC;QAAE,KAAK,EAAE,OAAO,CAAA;KAAE,CAAC,CAAC;IACrD,iBAAiB,EAAE,WAAW,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,OAAO,CAAA;KAAE,CAAC,CAAC;CACrE;AAED,cAAM,gBAAiB,SAAQ,WAAW,CAAC,oBAAoB,CAAC;CAAG;;;;AAEnE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsFG;AACH,qBAAa,YAAa,SAAQ,iBAAsC;IACtE,MAAM,CAAC,MAAM,iCAAwC;IAErD,qCAAqC;IACzB,OAAO,SAAM;IAEzB;;4CAEwC;IACX,QAAQ,UAAQ;IAE7C;;;;;;gCAM4B;IAC2B,UAAU,UAAS;IAE1E,sFAAsF;IACzD,GAAG,UAAQ;IAExC;;;;2EAIuE;IAC/B,UAAU,EAAE,MAAM,GAAG,IAAI,CAAY;IAE7E;;;6CAGyC;IACQ,kBAAkB,SAAM;IAEzE;;;;;;4EAMwE;IACf,aAAa,SAAK;IAE3E;;;;;;;;;;;;6EAYyE;IACnB,SAAS,UAAS;IAExE;;;;6EAIyE;IAC7B,SAAS,UAAS;IAE9D;;;;;2FAKuF;IAC7B,aAAa,UAAQ;IAE/E;;;8FAG0F;IAC1D,SAAS,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,kBAAkB,CAAC,CAAC;IAE/E;;;oBAGgB;IAC0C,aAAa,UAAS;IAEhF;;;;;;;;;kFAS8E;IACnB,cAAc,UAAS;IAElF;gFAC4E;IAC/C,IAAI,UAAS;IAE1C,6EAA6E;IAC7E,QAAQ,CAAC,WAAW,EAAE,SAAS,cAAc,EAAE,CAA8B;IAMpE,OAAO,CAAC,YAAY,CAAuB;IAEpD,OAAO,CAAC,IAAI,CAAC,CAAe;IAE5B;+BAC2B;IAC3B,OAAO,CAAC,WAAW,CAA6B;IAEhD,yFAAyF;IACzF,OAAO,CAAC,eAAe,CAAC,CAAkB;IAE1C;;;kGAG8F;IAC9F,OAAO,CAAC,uBAAuB,CAAsC;IAErE;kGAC8F;IAC9F,OAAO,CAAC,mBAAmB,CAAS;IAEpC;;;;;uFAKmF;IACnF,OAAO,CAAC,cAAc,CAA6B;IAEnD;4FACwF;IACxF,OAAO,CAAC,kBAAkB;IAS1B,OAAO,CAAC,kBAAkB;IAU1B;;;qGAGiG;IACjG,OAAO,CAAC,cAAc,CAAK;IAE3B;;;;;;;gCAO4B;IAC5B,OAAO,CAAC,mBAAmB,CAAqB;IAEhD,iBAAiB,IAAI,IAAI,CA2BxB;IAED,oBAAoB,IAAI,IAAI,CAI3B;IAED;;;;;iEAK6D;IAC7D,SAAS,CAAC,YAAY,IAAI,IAAI,CAI7B;IAMD,SAAS,CAAC,UAAU,CAAC,OAAO,EAAE,cAAc,GAAG,IAAI,CAsBlD;IAED,SAAS,CAAC,OAAO,CAAC,OAAO,EAAE,cAAc,GAAG,IAAI,CAU/C;IAED,OAAO,CAAC,cAAc;IAuEtB,OAAO,CAAC,aAAa;IAKrB;;;;0EAIsE;IACtE,OAAO,CAAC,cAAc;IAUtB;;;;oEAIgE;IAChE,OAAO,CAAC,iBAAiB;IAUzB;;;qEAGiE;IACjE,OAAO,CAAC,qBAAqB;IAK7B;;;;;;;;;8EAS0E;YAC5D,gBAAgB;IAmD9B,OAAO,CAAC,aAAa;IA8JrB;;uDAEmD;IACnD,cAAc,IAAI,mBAAmB,EAAE,CAEtC;IAED,OAAO,CAAC,WAAW;IAMnB,UAAgB,WAAW,CAAC,MAAM,EAAE,UAAU,GAAG,OAAO,CAAC,OAAO,CAAC,CAWhE;IAED,OAAO,CAAC,mBAAmB;IAU3B;;mCAE+B;IAC/B,OAAO,CAAC,uBAAuB;IAO/B,OAAO,CAAC,oBAAoB;IAQ5B;;;;kCAI8B;IAC9B,SAAS,CAAC,sBAAsB,CAAC,KAAK,EAAE,KAAK,GAAG,UAAU,GAAG,IAAI,CAIhE;IAID,OAAO,CAAC,qBAAqB;IAK7B;;;;4FAIwF;IACxF,OAAO,CAAC,iBAAiB;IA6BzB;;;;;sDAKkD;IAClD,OAAO,CAAC,kBAAkB;IAa1B,OAAO,CAAC,cAAc,CAkBpB;IAEF,MAAM,IAAI,cAAc,CAQvB;CACF;AAGD,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,qBAAqB;QAC7B,eAAe,EAAE,YAAY,CAAC;KAC/B;CACF"}
+{"version":3,"file":"markdown.class.d.ts","sourceRoot":"","sources":["../../../src/components/markdown/markdown.class.ts"],"names":[],"mappings":"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"}

package/dist/components/markdown/markdown.class.js

@@ -61,7 +61,7 @@ const HIGHLIGHT_TONES = ['accent', 'success', 'warning', 'danger', 'neutral'];
  *  scrolled out of the content long ago. */
 const HIGHLIGHT_CACHE_MAX = 100;
 // -- math (KaTeX) -----------------------------------------------------------------------------
-/** Resolved once per page and reused by every `<lyra-markdown>` instance, mirroring
+/** Resolved once per page and reused by every `<lr-markdown>` instance, mirroring
  *  `markdown-loader.ts`'s own "warm cache" shape: `undefined` means no load has been kicked off
  *  yet, `null` a load finished but the peer isn't installed, and it's set to `null` synchronously
  *  the instant a load starts as an in-flight marker so a second concurrent instance never kicks off
@@ -86,7 +86,7 @@ function getKatexIfLoaded() {
 /** Whether the `katex` load has definitively finished with no peer available -- distinct from
  *  `getKatexIfLoaded()` returning falsy, which also covers a load that's merely still in flight
  *  (the state a math token's render-time literal fallback uses regardless of which case it is).
- *  Used only to decide whether a literal fallback should also report `lyra-render-error`. */
+ *  Used only to decide whether a literal fallback should also report `lr-render-error`. */
 function isKatexConfirmedMissing() {
     return (katexOverride !== undefined ? katexOverride : resolvedKatex) === null;
 }
@@ -124,16 +124,16 @@ function mathExtension(renderMath) {
 }
 /**
  * Rewrites shiki's generated `<pre>`/`<code>` hast nodes so the highlighted output keeps
- * `<lyra-markdown>`'s own `part="code-block"` hook and a `language-${lang}` class on `<code>` --
+ * `<lr-markdown>`'s own `part="code-block"` hook and a `language-${lang}` class on `<code>` --
  * matching today's plain-render output shape exactly, so existing consumer CSS targeting either
  * keeps working whether or not a given block ended up highlighted. A separate, purpose-built
  * function from `code-block.class.ts`'s own (private, non-exported) `partTransformer` -- that one
- * targets `<lyra-code-block>`'s own `part="pre"`/`part="code"`/line-numbers contract, which doesn't
+ * targets `<lr-code-block>`'s own `part="pre"`/`part="code"`/line-numbers contract, which doesn't
  * apply here.
  */
 function markdownCodeTransformer(lang) {
     return {
-        name: 'lyra-markdown-code-block',
+        name: 'lr-markdown-code-block',
         pre(node) {
             node.properties.part = ['code-block'];
             delete node.properties.tabindex;
@@ -151,7 +151,7 @@ function markdownCodeTransformer(lang) {
 class LyraMarkdownBase extends LyraElement {
 }
 /**
- * `<lyra-markdown>` — sanitized Markdown-to-HTML rendering (GFM tables,
+ * `<lr-markdown>` — sanitized Markdown-to-HTML rendering (GFM tables,
  * fenced code blocks, links, blockquotes) built on the optional peer
  * dependencies `marked` (parsing) and `dompurify` (sanitizing), both
  * lazy-loaded via `markdown-loader.ts` on first connect.
@@ -159,9 +159,9 @@ class LyraMarkdownBase extends LyraElement {
  * Rendering never ships unsanitized or broken markup silently:
  * - If `marked` fails to load, or throws while parsing malformed input, the
  *   component falls back to plain text (`white-space: pre-wrap`, no HTML
- *   parsing at all) and fires `lyra-render-error`.
+ *   parsing at all) and fires `lr-render-error`.
  * - If `sanitize` is `true` (the default) and `dompurify` fails to load, the
- *   component *also* falls back to plain text + `lyra-render-error` — it
+ *   component *also* falls back to plain text + `lr-render-error` — it
  *   never renders marked's raw HTML output when sanitization was requested
  *   (or defaulted to) but is unavailable, even though `marked` itself loaded
  *   fine.
@@ -173,7 +173,7 @@ class LyraMarkdownBase extends LyraElement {
  * part) is also, unconditionally and by default, a brief *transient* state on
  * every connect, not just a failure path: `connectedCallback()`'s dynamic
  * `import()` of `marked`/`dompurify` (see `markdown-loader.ts`) is
- * asynchronous, so the very first paint of any `<lyra-markdown>` on a page
+ * asynchronous, so the very first paint of any `<lr-markdown>` on a page
  * shows plain text for at least one microtask — even when both peers are
  * already installed and load without error — until that import resolves and
  * a second render replaces it with the real Markdown output. Set
@@ -185,9 +185,9 @@ class LyraMarkdownBase extends LyraElement {
  * directly into the produced HTML — a single pass, not a second DOM walk
  * after insertion.
  *
- * Fenced code blocks are syntax-highlighted via the same optional `shiki` peer `<lyra-code-block>`
+ * Fenced code blocks are syntax-highlighted via the same optional `shiki` peer `<lr-code-block>`
  * uses (`highlightCode`, default `true` — a pure upgrade gated by whether `shiki` is installed at
- * all, not a separate opt-in). `languages`/`languagesOnly` mirror `<lyra-code-block>`'s own
+ * all, not a separate opt-in). `languages`/`languagesOnly` mirror `<lr-code-block>`'s own
  * fine-grained bundle-size controls. The very first render of any content is always plain
  * (identical to today's output); highlighting arrives as an asynchronous upgrade one render later,
  * once shiki resolves. No highlighting is attempted while `streaming` is `true` — it applies once a
@@ -208,20 +208,20 @@ class LyraMarkdownBase extends LyraElement {
  * `renderToString(tex, { output: 'mathml' })` -- MathML Core renders natively and accessibly in
  * evergreen browsers with no extra stylesheet or webfont needing to cross the shadow boundary. A
  * missing `katex` peer renders the literal, unparsed TeX source (delimiters included) and fires one
- * `lyra-render-error`.
+ * `lr-render-error`.
  *
- * @customElement lyra-markdown
- * @event lyra-link-click - Fired (and the click prevented) when a rendered
+ * @customElement lr-markdown
+ * @event lr-link-click - 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.
- * @event lyra-render-error - Fired whenever rendering falls back to plain
+ * @event lr-render-error - Fired whenever rendering falls back to plain
  *   text, or `math` is set but the `katex` peer isn't installed. `detail: { error: unknown }`.
- * @event lyra-highlight-activate - A painted `text-quote` highlight was clicked. `detail: { id }`.
- * @event lyra-text-select - Fired on selection end inside the rendered content. `detail: { text,
+ * @event lr-highlight-activate - A painted `text-quote` highlight was clicked. `detail: { id }`.
+ * @event lr-text-select - 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.
- * @event lyra-anchor-result - Fired after an `anchor` property assignment or a `scrollToAnchor()`
+ * @event lr-anchor-result - Fired after an `anchor` property assignment or a `scrollToAnchor()`
  *   call is applied. `detail: { found }`.
  * @csspart content - The wrapper around the rendered (or plain-text
  *   fallback) output.
@@ -264,7 +264,7 @@ export class LyraMarkdown extends DocumentAnchorTarget(LyraMarkdownBase) {
         this.linkTarget = '_blank';
         /** When set, a rendered link whose `href` starts with this prefix is
          *  treated as internal — its click is intercepted and reported via
-         *  `lyra-link-click` instead of navigating. Empty (the default) means
+         *  `lr-link-click` instead of navigating. Empty (the default) means
          *  every link is treated as external. */
         this.internalLinkPrefix = '';
         /** Added to every rendered heading's source `token.depth` before emitting
@@ -278,11 +278,11 @@ export class LyraMarkdown extends DocumentAnchorTarget(LyraMarkdownBase) {
         /** When `true`, `connectedCallback()` skips awaiting `loadMarkdownDeps()`'s
          *  dynamic `import()` if the shared `marked`/`dompurify` module cache (see
          *  `markdown-loader.ts`'s `getMarkdownDepsIfLoaded()`) has *already*
-         *  resolved — e.g. because an earlier `<lyra-markdown>` instance on the
+         *  resolved — e.g. because an earlier `<lr-markdown>` instance on the
          *  page already finished loading, or the consumer primed the cache
          *  directly by calling `loadMarkdownDeps()` themselves at startup — and
          *  renders synchronously instead. When the cache isn't warm yet (most
-         *  notably: the very first `<lyra-markdown>` ever connected on a page,
+         *  notably: the very first `<lr-markdown>` ever connected on a page,
          *  since nothing has called `loadMarkdownDeps()` before it), this still
          *  falls back to the normal async path — a dynamic `import()` can't be
          *  made synchronous, so this is a fast path for the common "already warm"
@@ -293,16 +293,16 @@ export class LyraMarkdown extends DocumentAnchorTarget(LyraMarkdownBase) {
          *  continue to render immediately; while this is `true`, the host remains
          *  `aria-busy="true"` so assistive technology knows the rendered document
          *  is not final. Set it back to `false` with the final content update.
-         *  Reflects so a consumer can also target `lyra-markdown[streaming]`. */
+         *  Reflects so a consumer can also target `lr-markdown[streaming]`. */
         this.streaming = false;
-        /** Syntax-highlights fenced code blocks via the same optional `shiki` peer `<lyra-code-block>`
+        /** Syntax-highlights fenced code blocks via the same optional `shiki` peer `<lr-code-block>`
          *  uses. `true` (the default) upgrades every fenced block from plain `<pre><code>` once the peer
          *  is available -- a pure upgrade, not a behavior change gated on opt-in, since it's itself gated
          *  transparently by whether `shiki` is installed at all (an app that never installs it sees
          *  byte-identical output to today). Set `false` to keep plain output even when `shiki` is
          *  installed. No effect while `streaming` is `true` -- see that property's own doc. */
         this.highlightCode = true;
-        /** Same purpose as `<lyra-code-block>`'s own `languagesOnly` -- skips the default full-bundle
+        /** Same purpose as `<lr-code-block>`'s own `languagesOnly` -- skips the default full-bundle
          *  loader entirely, so a fenced block whose language isn't in `languages` falls back to plain
          *  unhighlighted text rather than reaching for the full bundle. No effect unless `languages` is
          *  also set. */
@@ -326,7 +326,7 @@ export class LyraMarkdown extends DocumentAnchorTarget(LyraMarkdownBase) {
         // `null` covers both "the optional peers are still loading" and "a render
         // attempt just fell back after a failure" — the two states intentionally
         // look identical (plain text, see render()) since a consumer distinguishes
-        // them via `lyra-render-error`, not a visual difference.
+        // them via `lr-render-error`, not a visual difference.
         this.renderedHtml = null;
         /** Document-ordered heading outline computed on every parse (see `getHeadingTree()`), regardless
          *  of `headingAnchors`. */
@@ -336,7 +336,7 @@ export class LyraMarkdown extends DocumentAnchorTarget(LyraMarkdownBase) {
          *  element to attach a click listener to, so activation is resolved by comparing the click point
          *  against each range's own `getClientRects()` instead, uniformly across both paint paths. */
         this.resolvedHighlightRanges = [];
-        /** Guards `lyra-render-error` so a permanently-missing `katex` peer reports once per instance,
+        /** Guards `lr-render-error` so a permanently-missing `katex` peer reports once per instance,
          *  not on every subsequent re-render while `math` stays on. Reset whenever `math` toggles. */
         this.mathFailureReported = false;
         /** `(lang, code)` -> already-highlighted HTML, content-addressed (see `PendingHighlight`'s doc).
@@ -348,7 +348,7 @@ export class LyraMarkdown extends DocumentAnchorTarget(LyraMarkdownBase) {
         this.highlightCache = new Map();
         /** Bumped on every `highlightPending()` call, including ones that end up not actually loading
          *  anything -- guards against a newer `content`/`streaming` change superseding an older in-flight
-         *  highlight, exactly mirroring `<lyra-code-block>`'s own `highlightToken` field for the identical
+         *  highlight, exactly mirroring `<lr-code-block>`'s own `highlightToken` field for the identical
          *  race (an async grammar load resolving after a newer call already produced correct output). */
         this.highlightToken = 0;
         /** Keys from `PendingHighlight` that failed to highlight -- peer missing, language unrecognized,
@@ -358,7 +358,7 @@ export class LyraMarkdown extends DocumentAnchorTarget(LyraMarkdownBase) {
          *  `highlightPending()` itself triggers on completion -- would rediscover it as pending and retry
          *  it again, forever. Mirrors `code-loader.ts`'s own `unsupportedLanguages` Set, which exists for
          *  the identical reason one level down (a single unrecognized `language` value on
-         *  `<lyra-code-block>`). */
+         *  `<lr-code-block>`). */
         this.failedHighlightKeys = new Set();
         // A single delegated listener on the content wrapper (not one per <a>) —
         // the rendered markup is fully replaced on every content change, so a
@@ -366,7 +366,7 @@ export class LyraMarkdown extends DocumentAnchorTarget(LyraMarkdownBase) {
         this.onContentClick = (e) => {
             const highlightId = this.hitTestHighlightAt(e.clientX, e.clientY);
             if (highlightId) {
-                this.emit('lyra-highlight-activate', { id: highlightId });
+                this.emit('lr-highlight-activate', { id: highlightId });
                 return;
             }
             const prefix = this.internalLinkPrefix;
@@ -383,7 +383,7 @@ export class LyraMarkdown extends DocumentAnchorTarget(LyraMarkdownBase) {
             if (!href.startsWith(prefix))
                 return;
             e.preventDefault();
-            this.emit('lyra-link-click', { href, internal: true });
+            this.emit('lr-link-click', { href, internal: true });
         };
     }
     static { this.styles = [LyraElement.styles, styles, srOnly]; }
@@ -425,7 +425,7 @@ export class LyraMarkdown extends DocumentAnchorTarget(LyraMarkdownBase) {
         void loadMarkdownDeps().then((resolved) => {
             // The (module-cached, page-lifetime) loadMarkdownDeps() promise can
             // resolve after this instance was removed from the DOM -- e.g. an
-            // <lyra-markdown> inside a conditionally-rendered chat message or a
+            // <lr-markdown> inside a conditionally-rendered chat message or a
             // virtualized list. Without this guard, a detached instance would
             // still have its `deps` set and renderMarkdown() called, mutating the
             // @state() renderedHtml property and scheduling a Lit update no one
@@ -442,7 +442,7 @@ export class LyraMarkdown extends DocumentAnchorTarget(LyraMarkdownBase) {
         this.highlightHandle?.release();
         this.highlightHandle = undefined;
     }
-    /** Binds selection -> `lyra-text-select` once, on the stable `[part="content"]` wrapper --
+    /** Binds selection -> `lr-text-select` once, on the stable `[part="content"]` wrapper --
      *  re-renders only replace that wrapper's children via `unsafeHTML`, never the wrapper itself.
      *  `bindTextSelection` is `protected` on the mixin's own narrowed return type (deliberately not
      *  part of `LyraAnchorTarget`'s public surface -- see `anchor-target.ts`'s class doc), so it's
@@ -498,7 +498,7 @@ export class LyraMarkdown extends DocumentAnchorTarget(LyraMarkdownBase) {
             return;
         if (!deps.marked) {
             // markdown-loader.ts already logged the specific import failure.
-            this.applyFallback(new Error('<lyra-markdown> could not render: the "marked" peer dependency failed to load.'));
+            this.applyFallback(new Error('<lr-markdown> could not render: the "marked" peer dependency failed to load.'));
             return;
         }
         const pendingKeys = [];
@@ -531,7 +531,7 @@ export class LyraMarkdown extends DocumentAnchorTarget(LyraMarkdownBase) {
             return;
         }
         if (!deps.DOMPurify) {
-            const error = new Error('<lyra-markdown> could not render: sanitize is enabled (the default) but the "dompurify" peer ' +
+            const error = new Error('<lr-markdown> could not render: sanitize is enabled (the default) but the "dompurify" peer ' +
                 'dependency failed to load — refusing to render unsanitized HTML. Install it with `pnpm add ' +
                 'dompurify`, or set sanitize="false" to explicitly opt out of sanitization.');
             console.warn(error.message);
@@ -559,10 +559,10 @@ export class LyraMarkdown extends DocumentAnchorTarget(LyraMarkdownBase) {
     }
     applyFallback(error) {
         this.renderedHtml = null;
-        this.emit('lyra-render-error', { error });
+        this.emit('lr-render-error', { error });
     }
     /** Kicks off the shared `katex` load the first time `math` needs it and no attempt is already
-     *  in flight (module-scoped, so every `<lyra-markdown>` instance on the page shares one load --
+     *  in flight (module-scoped, so every `<lr-markdown>` instance on the page shares one load --
      *  mirrors `markdown-loader.ts`'s own warm-cache shape). Skipped entirely under
      *  `__setKatexForTesting()` -- that seam controls math-rendering behavior directly and must never
      *  race a real, unmocked `import('katex')` settling underneath it. */
@@ -577,7 +577,7 @@ export class LyraMarkdown extends DocumentAnchorTarget(LyraMarkdownBase) {
             this.renderMarkdown();
         });
     }
-    /** Fires `lyra-render-error` once per instance for a permanently-missing `katex` peer. Called
+    /** Fires `lr-render-error` once per instance for a permanently-missing `katex` peer. Called
      *  only once `renderMarkdown()` has confirmed the peer is actually missing (`katexOverride` or
      *  the resolved module is `null`) -- a math token rendering its literal fallback while the load
      *  is merely still in flight (the same one-microtask transient window every other optional peer
@@ -586,8 +586,8 @@ export class LyraMarkdown extends DocumentAnchorTarget(LyraMarkdownBase) {
         if (this.mathFailureReported)
             return;
         this.mathFailureReported = true;
-        this.emit('lyra-render-error', {
-            error: new Error('<lyra-markdown> needs the optional peer dependency `katex` to render math (the `math` property is set) — install it with `pnpm add katex`.'),
+        this.emit('lr-render-error', {
+            error: new Error('<lr-markdown> needs the optional peer dependency `katex` to render math (the `math` property is set) — install it with `pnpm add katex`.'),
         });
     }
     /** Kicks off async highlighting for `pendingKeys` (see `highlightPending()`) unless there's
@@ -619,7 +619,7 @@ export class LyraMarkdown extends DocumentAnchorTarget(LyraMarkdownBase) {
                 hl = await loadShikiHighlighterCore(languages);
             }
             else if (this.languagesOnly) {
-                // languagesOnly skips the default full-bundle loader entirely (mirrors <lyra-code-block>) --
+                // languagesOnly skips the default full-bundle loader entirely (mirrors <lr-code-block>) --
                 // permanent for this key: failedHighlightKeys is never cleared, and languages/languagesOnly
                 // aren't in willUpdate()'s trigger list, so changing either doesn't retry it on its own.
                 this.failedHighlightKeys.add(pending.key);
@@ -923,7 +923,7 @@ export class LyraMarkdown extends DocumentAnchorTarget(LyraMarkdownBase) {
             // module is shared by every adopting viewer, so it can't know this component's part naming)
             // -- stamped here so a consumer can still target `::part(highlight)` in browsers lacking the
             // CSS Custom Highlight API. Nothing to stamp on the API path: no DOM element is created there.
-            for (const mark of root.querySelectorAll('mark[data-lyra-highlight-tone]')) {
+            for (const mark of root.querySelectorAll('mark[data-lr-highlight-tone]')) {
                 if (!mark.hasAttribute('part'))
                     mark.setAttribute('part', 'highlight');
             }
@@ -932,7 +932,7 @@ export class LyraMarkdown extends DocumentAnchorTarget(LyraMarkdownBase) {
     /** Hit-tests a click point against every currently-resolved highlight's `getClientRects()`,
      *  topmost (last-resolved) first. The CSS Custom Highlight API paints ranges without creating any
      *  DOM element to attach a click listener to, so this is the only activation path that works
-     *  identically on both paint paths -- mirrors `<lyra-pdf-viewer>`'s own coordinate-based
+     *  identically on both paint paths -- mirrors `<lr-pdf-viewer>`'s own coordinate-based
      *  `onPageClick()` hit-test for the same reason (its own painted highlights sit under a text
      *  layer that intercepts most pointer events). */
     hitTestHighlightAt(x, y) {