@aceshooting/lyra-ui 1.1.0 → 2.0.0

package/dist/components/stat/stat.styles.js

@@ -84,6 +84,13 @@ export const styles = css `
   [part='spark'][hidden] {
     display: none;
   }
+  [part='sub'] {
+    font-size: 0.8125rem;
+    font-weight: 600;
+  }
+  [part='sub'][hidden] {
+    display: none;
+  }
   [part='caption'] {
     font-size: 0.8125rem;
     color: var(--lyra-color-text-quiet);
@@ -127,4 +134,17 @@ export const styles = css `
   :host([emphasis][variant='neutral']) [part='value'] {
     color: var(--lyra-color-brand);
   }
+  :host([prose]) [part='value'] {
+    font-size: 0.9375rem;
+    font-weight: 400;
+    font-family: inherit;
+    color: var(--lyra-color-text-quiet);
+  }
+  :host([prose]) [part='unit'] {
+    display: none;
+  }
+  :host([compact]) [part='base'] {
+    padding: var(--lyra-space-s);
+    gap: 0.125rem;
+  }
 `;

package/dist/components/stream-status/stream-status.d.ts

@@ -0,0 +1,110 @@
+import { type TemplateResult, type PropertyValues } from 'lit';
+import { LyraElement } from '../../internal/lyra-element.js';
+import '../live-region/live-region.js';
+export type StreamStatusPhase = 'idle' | 'connecting' | 'streaming' | 'stalled';
+/**
+ * `<lyra-stream-status>` — a compact status indicator for a single streaming
+ * connection (SSE, WebSocket, long-poll, …), with built-in heartbeat-aware
+ * stall detection.
+ *
+ * The host drives `phase` directly for `idle`/`connecting`/`streaming`, and
+ * calls `recordActivity()` on every *semantic* frame received while
+ * streaming — a real content chunk, never a transport-level keep-alive ping.
+ * This component has no payload-inspection logic of its own: "ignore
+ * heartbeats" is entirely a call-site discipline — the host simply never
+ * calls `recordActivity()` for a ping, so pings never reset the stall timer
+ * and a connection that's only sending keep-alives (no real content) for
+ * longer than `stall-threshold-ms` correctly reads as stalled.
+ *
+ * Internally, an inactivity timer runs only while `phase === 'streaming'`.
+ * It's (re)armed whenever the phase transitions to `'streaming'` (directly,
+ * or via `recordActivity()` recovering from `'stalled'`) and on every
+ * subsequent `recordActivity()` call while already streaming; it's disarmed
+ * the instant `phase` becomes anything else, including a host-driven
+ * reassignment away from `'streaming'` — so a stale timer can never fire a
+ * stall transition after the host has already moved on. If it ever fires,
+ * `phase` becomes `'stalled'` and `lyra-stall` is dispatched.
+ *
+ * `phase` remains a fully public, directly settable property at all times —
+ * a host can assign `'stalled'` (or any other phase) itself as a manual
+ * override, and this component never fights that assignment. `lyra-stall`/
+ * `lyra-recover` fire on *any* transition into/out of `'stalled'`
+ * respectively, whether timer-driven or host-driven, and never for a
+ * reassignment to the same value (Lit's default `hasChanged` already skips a
+ * no-op set, same as every other reflected `@property` in this library).
+ * Like `<lyra-chat-message>`'s `status`, whatever phase this element happens
+ * to *mount* with is never itself treated as an eventful transition — only a
+ * later change fires an event or an announcement.
+ *
+ * Accessibility: phase transitions into/out of `'stalled'` are announced
+ * through an internal `<lyra-live-region>` (see that component for the
+ * throttled/coalesced-announcement machinery this composes) rather than a
+ * hand-rolled `aria-live` region. `recordActivity()` itself never announces
+ * anything, no matter how often the host calls it — only the *transition*
+ * announces, exactly once per transition, which is the entire point of
+ * routing through the throttled announcer instead of writing to a live
+ * region on every call. Entering `'stalled'` announces with `mode="assertive"`
+ * (a stall can need the user's attention, e.g. before they give up and
+ * navigate away); recovering back out of `'stalled'` announces with
+ * `mode="polite"` (good news doesn't need to interrupt). The decorative
+ * indicator dot is `aria-hidden` — it's a color/motion cue only, never the
+ * sole carrier of state.
+ *
+ * Visual: `'stalled'` is styled as a warning, not a danger — a stall is
+ * usually recoverable (the stream may resume on its own, or the host's own
+ * retry logic may kick in), so treating it as an actionable warning rather
+ * than a hard failure keeps the tone proportionate. A host that wants to
+ * escalate to danger styling after N stalls can scope its own CSS off
+ * `[phase="stalled"]`, or simply stop rendering this component and show its
+ * own danger-styled error state instead.
+ *
+ * @customElement lyra-stream-status
+ * @slot - Custom copy shown only while `phase="stalled"` (e.g. "Taking longer than usual…"). A sensible built-in default is used when nothing is slotted.
+ * @slot actions - A stop/retry button row. Always present in the template regardless of `phase` — visibility is driven purely by whether anything is slotted, not by `phase`; what to put here, and when, is entirely the host's call.
+ * @event lyra-stall - Fired whenever `phase` transitions into `'stalled'` from anything else (timer-driven, or a direct host assignment).
+ * @event lyra-recover - Fired whenever `phase` transitions out of `'stalled'` to anything else (via `recordActivity()`, or a direct host assignment).
+ * @csspart base - The root layout container.
+ * @csspart indicator - The decorative (`aria-hidden`) status dot.
+ * @csspart message - Wrapper around the default slot; only rendered while `phase="stalled"`.
+ * @csspart actions - Wrapper around the `actions` slot.
+ */
+export declare class LyraStreamStatus extends LyraElement {
+    static styles: import("lit").CSSResultGroup[];
+    /** Current connection phase. Settable directly by the host at any time —
+     *  see the class doc for how that interacts with the internal stall timer. */
+    phase: StreamStatusPhase;
+    /** How long `phase` may stay `'streaming'` with no `recordActivity()` call
+     *  before this component declares it stalled. */
+    stallThresholdMs: number;
+    private stallTimer?;
+    private hasActionsSlot;
+    private liveRegion?;
+    protected willUpdate(): void;
+    protected updated(changed: PropertyValues): void;
+    disconnectedCallback(): void;
+    /**
+     * Call on every semantic (non-heartbeat) frame received while streaming.
+     * - While `phase === 'streaming'`: (re)arms the stall timer, pushing the
+     *   stall deadline `stall-threshold-ms` further out.
+     * - While `phase === 'stalled'`: recovers — `phase` becomes `'streaming'`
+     *   again, `lyra-recover` fires, and the stall timer is armed fresh (same
+     *   as the bullet above), all via the same `updated()` transition handling
+     *   a direct host assignment would also go through.
+     * - While `phase` is `'idle'` or `'connecting'`: a no-op. A host may call
+     *   this defensively before formally flipping to `'streaming'`; it must
+     *   never throw or start a timer early.
+     */
+    recordActivity(): void;
+    private onPhaseChanged;
+    private armStallTimer;
+    private disarmStallTimer;
+    private announceTransition;
+    private hasSlotted;
+    private onActionsSlotChange;
+    render(): TemplateResult;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'lyra-stream-status': LyraStreamStatus;
+    }
+}

package/dist/components/stream-status/stream-status.js

@@ -0,0 +1,210 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { html, nothing } from 'lit';
+import { property, state, query } from 'lit/decorators.js';
+import { LyraElement } from '../../internal/lyra-element.js';
+import { defineElement } from '../../internal/prefix.js';
+import '../live-region/live-region.js';
+import { styles } from './stream-status.styles.js';
+const DEFAULT_STALL_MESSAGE = 'Taking longer than usual…';
+const STALL_ANNOUNCEMENT = 'Connection stalled.';
+const RECOVER_ANNOUNCEMENT = 'Connection restored.';
+/**
+ * `<lyra-stream-status>` — a compact status indicator for a single streaming
+ * connection (SSE, WebSocket, long-poll, …), with built-in heartbeat-aware
+ * stall detection.
+ *
+ * The host drives `phase` directly for `idle`/`connecting`/`streaming`, and
+ * calls `recordActivity()` on every *semantic* frame received while
+ * streaming — a real content chunk, never a transport-level keep-alive ping.
+ * This component has no payload-inspection logic of its own: "ignore
+ * heartbeats" is entirely a call-site discipline — the host simply never
+ * calls `recordActivity()` for a ping, so pings never reset the stall timer
+ * and a connection that's only sending keep-alives (no real content) for
+ * longer than `stall-threshold-ms` correctly reads as stalled.
+ *
+ * Internally, an inactivity timer runs only while `phase === 'streaming'`.
+ * It's (re)armed whenever the phase transitions to `'streaming'` (directly,
+ * or via `recordActivity()` recovering from `'stalled'`) and on every
+ * subsequent `recordActivity()` call while already streaming; it's disarmed
+ * the instant `phase` becomes anything else, including a host-driven
+ * reassignment away from `'streaming'` — so a stale timer can never fire a
+ * stall transition after the host has already moved on. If it ever fires,
+ * `phase` becomes `'stalled'` and `lyra-stall` is dispatched.
+ *
+ * `phase` remains a fully public, directly settable property at all times —
+ * a host can assign `'stalled'` (or any other phase) itself as a manual
+ * override, and this component never fights that assignment. `lyra-stall`/
+ * `lyra-recover` fire on *any* transition into/out of `'stalled'`
+ * respectively, whether timer-driven or host-driven, and never for a
+ * reassignment to the same value (Lit's default `hasChanged` already skips a
+ * no-op set, same as every other reflected `@property` in this library).
+ * Like `<lyra-chat-message>`'s `status`, whatever phase this element happens
+ * to *mount* with is never itself treated as an eventful transition — only a
+ * later change fires an event or an announcement.
+ *
+ * Accessibility: phase transitions into/out of `'stalled'` are announced
+ * through an internal `<lyra-live-region>` (see that component for the
+ * throttled/coalesced-announcement machinery this composes) rather than a
+ * hand-rolled `aria-live` region. `recordActivity()` itself never announces
+ * anything, no matter how often the host calls it — only the *transition*
+ * announces, exactly once per transition, which is the entire point of
+ * routing through the throttled announcer instead of writing to a live
+ * region on every call. Entering `'stalled'` announces with `mode="assertive"`
+ * (a stall can need the user's attention, e.g. before they give up and
+ * navigate away); recovering back out of `'stalled'` announces with
+ * `mode="polite"` (good news doesn't need to interrupt). The decorative
+ * indicator dot is `aria-hidden` — it's a color/motion cue only, never the
+ * sole carrier of state.
+ *
+ * Visual: `'stalled'` is styled as a warning, not a danger — a stall is
+ * usually recoverable (the stream may resume on its own, or the host's own
+ * retry logic may kick in), so treating it as an actionable warning rather
+ * than a hard failure keeps the tone proportionate. A host that wants to
+ * escalate to danger styling after N stalls can scope its own CSS off
+ * `[phase="stalled"]`, or simply stop rendering this component and show its
+ * own danger-styled error state instead.
+ *
+ * @customElement lyra-stream-status
+ * @slot - Custom copy shown only while `phase="stalled"` (e.g. "Taking longer than usual…"). A sensible built-in default is used when nothing is slotted.
+ * @slot actions - A stop/retry button row. Always present in the template regardless of `phase` — visibility is driven purely by whether anything is slotted, not by `phase`; what to put here, and when, is entirely the host's call.
+ * @event lyra-stall - Fired whenever `phase` transitions into `'stalled'` from anything else (timer-driven, or a direct host assignment).
+ * @event lyra-recover - Fired whenever `phase` transitions out of `'stalled'` to anything else (via `recordActivity()`, or a direct host assignment).
+ * @csspart base - The root layout container.
+ * @csspart indicator - The decorative (`aria-hidden`) status dot.
+ * @csspart message - Wrapper around the default slot; only rendered while `phase="stalled"`.
+ * @csspart actions - Wrapper around the `actions` slot.
+ */
+export class LyraStreamStatus extends LyraElement {
+    constructor() {
+        super(...arguments);
+        /** Current connection phase. Settable directly by the host at any time —
+         *  see the class doc for how that interacts with the internal stall timer. */
+        this.phase = 'idle';
+        /** How long `phase` may stay `'streaming'` with no `recordActivity()` call
+         *  before this component declares it stalled. */
+        this.stallThresholdMs = 10000;
+        this.hasActionsSlot = false;
+        this.onActionsSlotChange = (e) => {
+            this.hasActionsSlot = e.target.assignedElements({ flatten: true }).length > 0;
+        };
+    }
+    static { this.styles = [LyraElement.styles, styles]; }
+    willUpdate() {
+        if (!this.hasUpdated) {
+            this.hasActionsSlot = this.hasSlotted('actions');
+        }
+    }
+    // `changed.get('phase')` is `undefined` on the very first update, for the
+    // same reason documented on lyra-chat-message's identical `updated()`
+    // guard: Lit only records the *first* old value seen since the last
+    // completed update, and the constructor's field-initializer assignment is
+    // that first change, from the truly-unset internal slot. That naturally
+    // skips firing an event/announcement for whatever phase this element
+    // happens to mount with, while still arming the stall timer below if it
+    // mounts already `'streaming'`.
+    updated(changed) {
+        if (changed.has('phase')) {
+            this.onPhaseChanged(changed.get('phase'));
+        }
+    }
+    disconnectedCallback() {
+        super.disconnectedCallback();
+        this.disarmStallTimer();
+    }
+    /**
+     * Call on every semantic (non-heartbeat) frame received while streaming.
+     * - While `phase === 'streaming'`: (re)arms the stall timer, pushing the
+     *   stall deadline `stall-threshold-ms` further out.
+     * - While `phase === 'stalled'`: recovers — `phase` becomes `'streaming'`
+     *   again, `lyra-recover` fires, and the stall timer is armed fresh (same
+     *   as the bullet above), all via the same `updated()` transition handling
+     *   a direct host assignment would also go through.
+     * - While `phase` is `'idle'` or `'connecting'`: a no-op. A host may call
+     *   this defensively before formally flipping to `'streaming'`; it must
+     *   never throw or start a timer early.
+     */
+    recordActivity() {
+        if (this.phase === 'streaming') {
+            this.armStallTimer();
+        }
+        else if (this.phase === 'stalled') {
+            this.phase = 'streaming';
+        }
+    }
+    onPhaseChanged(previous) {
+        if (this.phase === 'streaming') {
+            this.armStallTimer();
+        }
+        else {
+            this.disarmStallTimer();
+        }
+        if (previous === undefined)
+            return;
+        if (this.phase === 'stalled' && previous !== 'stalled') {
+            this.emit('lyra-stall');
+            this.announceTransition('assertive', STALL_ANNOUNCEMENT);
+        }
+        else if (previous === 'stalled' && this.phase !== 'stalled') {
+            this.emit('lyra-recover');
+            this.announceTransition('polite', RECOVER_ANNOUNCEMENT);
+        }
+    }
+    armStallTimer() {
+        this.disarmStallTimer();
+        const threshold = this.stallThresholdMs;
+        if (!Number.isFinite(threshold) || threshold <= 0)
+            return;
+        this.stallTimer = setTimeout(() => {
+            this.stallTimer = undefined;
+            this.phase = 'stalled';
+        }, threshold);
+    }
+    disarmStallTimer() {
+        if (this.stallTimer !== undefined) {
+            clearTimeout(this.stallTimer);
+            this.stallTimer = undefined;
+        }
+    }
+    announceTransition(mode, text) {
+        const region = this.liveRegion;
+        if (!region)
+            return;
+        region.mode = mode;
+        region.announce(text, { force: true });
+    }
+    hasSlotted(name) {
+        return Array.from(this.children).some((el) => el.getAttribute('slot') === name);
+    }
+    render() {
+        return html `
+      <div part="base">
+        <span part="indicator" aria-hidden="true"></span>
+        ${this.phase === 'stalled'
+            ? html `<div part="message"><slot>${DEFAULT_STALL_MESSAGE}</slot></div>`
+            : nothing}
+        <div part="actions" ?hidden=${!this.hasActionsSlot}>
+          <slot name="actions" @slotchange=${this.onActionsSlotChange}></slot>
+        </div>
+        <lyra-live-region></lyra-live-region>
+      </div>
+    `;
+    }
+}
+__decorate([
+    property({ reflect: true })
+], LyraStreamStatus.prototype, "phase", void 0);
+__decorate([
+    property({ type: Number, attribute: 'stall-threshold-ms' })
+], LyraStreamStatus.prototype, "stallThresholdMs", void 0);
+__decorate([
+    state()
+], LyraStreamStatus.prototype, "hasActionsSlot", void 0);
+__decorate([
+    query('lyra-live-region')
+], LyraStreamStatus.prototype, "liveRegion", void 0);
+defineElement('stream-status', LyraStreamStatus);

package/dist/components/stream-status/stream-status.styles.d.ts

@@ -0,0 +1 @@
+export declare const styles: import("lit").CSSResult;

package/dist/components/stream-status/stream-status.styles.js

@@ -0,0 +1,103 @@
+import { css } from 'lit';
+export const styles = css `
+  :host {
+    display: inline-flex;
+    vertical-align: middle;
+    /* Swapped per-phase by the :host([phase]) rules below, rather than
+       repeating color/opacity per rule -- same one-custom-property-per-tone
+       shape as lyra-tool-call-chip's --lyra-tool-call-chip-accent. */
+    --lyra-stream-status-dot-color: var(--lyra-color-text-quiet);
+    --lyra-stream-status-dot-opacity: 0.35;
+  }
+
+  /* 'connecting' gets a dimmer, static brand dot -- present but deliberately
+     quieter than 'streaming' so the two are never confused at a glance. */
+  :host([phase='connecting']) {
+    --lyra-stream-status-dot-color: var(--lyra-color-brand);
+    --lyra-stream-status-dot-opacity: 0.6;
+  }
+  :host([phase='streaming']) {
+    --lyra-stream-status-dot-color: var(--lyra-color-brand);
+    --lyra-stream-status-dot-opacity: 1;
+  }
+  /* Warning, not danger -- see the class doc's "Visual" section for why a
+     stall defaults to the recoverable/actionable tone. */
+  :host([phase='stalled']) {
+    --lyra-stream-status-dot-color: var(--lyra-color-warning);
+    --lyra-stream-status-dot-opacity: 1;
+  }
+
+  [part='base'] {
+    display: inline-flex;
+    align-items: center;
+    gap: var(--lyra-space-s);
+    border-radius: var(--lyra-radius);
+    transition:
+      background-color var(--lyra-transition-base),
+      border-color var(--lyra-transition-base);
+  }
+
+  /* The one "unmistakable" treatment the spec calls for: a stall tints the
+     whole row, not just the dot, so the message/actions read as one alert
+     unit rather than a plain dot next to unrelated-looking text. */
+  :host([phase='stalled']) [part='base'] {
+    padding: var(--lyra-space-xs) var(--lyra-space-s);
+    background: var(--lyra-color-warning-quiet);
+    border: 1px solid var(--lyra-color-warning);
+  }
+
+  [part='indicator'] {
+    flex: 0 0 auto;
+    inline-size: 0.5rem;
+    block-size: 0.5rem;
+    border-radius: 50%;
+    background: var(--lyra-stream-status-dot-color);
+    opacity: var(--lyra-stream-status-dot-opacity);
+    transition:
+      background-color var(--lyra-transition-base),
+      opacity var(--lyra-transition-base);
+  }
+
+  /* Only 'streaming' pulses -- a moving dot reads as "actively receiving
+     data right now"; every other phase (including 'stalled', which wants
+     steady attention via color/tint, not extra motion) stays static. Same
+     transition-cycle token/rationale as lyra-typing-indicator's pulse
+     variant -- see that component's styles for the full explanation of why
+     --lyra-transition-base (not -fast) is the right length for an ambient
+     loop. */
+  :host([phase='streaming']) [part='indicator'] {
+    animation: lyra-stream-status-pulse var(--lyra-transition-base) infinite;
+  }
+  @keyframes lyra-stream-status-pulse {
+    0%,
+    100% {
+      transform: scale(0.85);
+      opacity: 0.6;
+    }
+    50% {
+      transform: scale(1);
+      opacity: 1;
+    }
+  }
+  @media (prefers-reduced-motion: reduce) {
+    [part='indicator'] {
+      animation: none !important;
+    }
+  }
+
+  [part='message'] {
+    color: var(--lyra-color-warning);
+    font-size: 0.875rem;
+    font-weight: 600;
+    line-height: 1.3;
+  }
+
+  [part='actions'] {
+    display: inline-flex;
+    align-items: center;
+    gap: var(--lyra-space-xs);
+  }
+  [part='actions'][hidden] {
+    display: none;
+  }
+`;

package/dist/components/streaming-text/streaming-text.d.ts

@@ -0,0 +1,98 @@
+import { type TemplateResult, type PropertyValues } from 'lit';
+import { LyraElement } from '../../internal/lyra-element.js';
+import '../markdown/markdown.js';
+/** Runs {@link MARKDOWN_PATTERNS} against `text`, used whenever `markdown`
+ *  is left unset (auto-detect). Exported so the heuristic is directly
+ *  testable without going through the component's render cycle. */
+export declare function looksLikeMarkdown(text: string): boolean;
+/**
+ * `<lyra-streaming-text>` — a token-coalescing incremental text renderer for
+ * streaming assistant output, with an optional blinking cursor and
+ * auto-detected Markdown rendering.
+ *
+ * The host is expected to assign the *entire* current text on every update
+ * to `content`, not a delta -- this component does no accumulation or
+ * ordering of its own. That matches how most streaming-UI state (SSE/
+ * WebSocket token accumulation into a growing string in application state)
+ * is already managed.
+ *
+ * Token-by-token streaming can update `content` far faster than a human can
+ * usefully perceive a re-render -- dozens of times a second for a fast
+ * model. Re-rendering on every single assignment thrashes layout for no
+ * visible benefit, so updates funnel through `Announcer`
+ * (`../../internal/announcer.js`), reused here purely as the generic
+ * "coalesce rapid calls, flush the latest" timing primitive its own class
+ * doc says other components should reuse -- with none of its usual
+ * DOM/ARIA plumbing (that's `<lyra-live-region>`'s job, not this
+ * component's). Within any `coalesce-ms` window, only the *last* `content`
+ * value assigned actually reaches the rendered DOM. Two cases always bypass
+ * the throttle and flush immediately instead of waiting out the window: the
+ * very first `content` assignment after mount (so an already-complete
+ * message never shows an artificial startup delay), and any transition of
+ * `streaming` from `true` to `false` (so the final chunk of a finished
+ * stream can never be left stranded mid-window).
+ *
+ * `markdown` is a tri-state property, not a plain boolean: left unset (the
+ * default), it auto-detects via a lightweight regex heuristic (see
+ * `looksLikeMarkdown`) run against whatever text is currently displayed --
+ * good enough to route obviously-Markdown output through `<lyra-markdown>`
+ * without the host needing to know or declare it up front, at the cost of
+ * an occasional one-time mode flip if Markdown syntax only appears partway
+ * through a stream. Explicitly setting `markdown` to `true`/`false` always
+ * wins over the heuristic. Rendering itself is never reimplemented here:
+ * Markdown mode composes `<lyra-markdown>` (`../markdown/markdown.js`)
+ * directly, forwarding this component's own `streaming` through as that
+ * component's own forward-compatible `streaming` hint prop; plain-text mode
+ * renders into a `white-space: pre-wrap` span instead.
+ *
+ * The blinking cursor (shown only while `streaming` is `true`) degrades to
+ * a static, always-visible bar under `prefers-reduced-motion: reduce`
+ * rather than disabling the animation into an invisible frozen frame --
+ * the same pattern `<lyra-typing-indicator>`'s own `cursor` variant uses. In
+ * plain-text mode the cursor sits inline at the tail of the final
+ * character, since the text is one continuous inline flow; in Markdown
+ * mode it renders as its own trailing block below the rendered content
+ * instead of attempting to splice into whatever nested block Markdown
+ * happens to end with (a paragraph, a table cell, a list item, a fenced
+ * code block, …) -- genuinely interleaving into arbitrary rendered Markdown
+ * without reaching across `<lyra-markdown>`'s own shadow boundary isn't a
+ * tractable general solution, so this component doesn't attempt it.
+ *
+ * Purely presentational: no events, driven entirely by its properties. It
+ * also doesn't announce anything to assistive tech itself -- a host that
+ * needs streamed text announced already has `<lyra-live-region>` for that
+ * (composed, for example, inside `<lyra-chat-message>`).
+ *
+ * @customElement lyra-streaming-text
+ * @csspart base - The root container.
+ * @csspart cursor - The blinking (or, under reduced motion, static) cursor bar. Only rendered while `streaming` is `true`.
+ */
+export declare class LyraStreamingText extends LyraElement {
+    static styles: import("lit").CSSResultGroup[];
+    /** The full current text so far -- always the complete string, never a
+     *  delta to append. */
+    content: string;
+    /** Shows the blinking cursor after the rendered text. Reflects, so a host
+     *  can also target `lyra-streaming-text[streaming]` in CSS. */
+    streaming: boolean;
+    /** Trailing-edge coalesce window, in ms, for `content` updates -- see the
+     *  class doc. */
+    coalesceMs: number;
+    /** `undefined` (default) auto-detects via `looksLikeMarkdown`; `true`/
+     *  `false` force that rendering mode regardless of content. */
+    markdown?: boolean;
+    private displayedContent;
+    private readonly coalescer;
+    constructor();
+    protected willUpdate(changed: PropertyValues): void;
+    disconnectedCallback(): void;
+    /** Whether Markdown mode is actually in effect right now, resolving the
+     *  tri-state `markdown` property against `looksLikeMarkdown`. */
+    private get effectiveMarkdown();
+    render(): TemplateResult;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'lyra-streaming-text': LyraStreamingText;
+    }
+}