@fusion.dev/helix-headless 0.104.1 → 0.106.0

package/dist/carousel/root/carousel-root.d.ts

@@ -4,20 +4,19 @@ import { type PropertyValues, type TemplateResult } from 'lit';
  * @summary Shows one slide of several, with controls to move between them.
  *
  * @description
- * The track is a scroller with scroll snapping, so a drag, a trackpad swipe,
- * and the browser's own momentum all work without being reimplemented. The
- * controls scroll it; they do not drive a transform.
+ * The track is a scroll container with scroll snapping, so dragging, trackpad
+ * swipes, and the browser's momentum scrolling all work. The controls scroll
+ * the track.
  *
- * Slides are the consumer's own elements, and nothing is written onto them. The
- * component renders a pane per slide carrying `role="group"`,
- * `aria-roledescription="slide"` and a name reading its position in the set,
- * and assigns the slide into it: a screen-reader user hears where they are, and
- * a slide that is itself a link is still a link. See `assign`.
+ * Slides are your own elements, and the carousel writes nothing onto them. It
+ * renders a pane for each slide with `role="group"`,
+ * `aria-roledescription="slide"`, and a name that gives the slide's position in
+ * the set, and assigns the slide into it. A screen reader announces the
+ * position, and a slide that is a link stays a link. See `assign`.
  *
- * **Rotation stops on focus and on hover, and once stopped it stays stopped.**
- * The APG is explicit: rotation must not resume unless the reader asks for it,
- * so hovering away does not start it again. The control names the action it
- * performs, and it is first in the tab order.
+ * **Rotation stops on focus and on hover, and stays stopped** until the user
+ * starts it again, as the APG requires. The rotation control is labeled with
+ * the action it performs and is first in the tab order.
  *
  * @since 0.1.0
  * @status stable
@@ -27,12 +26,12 @@ import { type PropertyValues, type TemplateResult } from 'lit';
  *
  * @slot - The slides.
  *
- * @event {HelixSelectEvent} helix-select - Fired before the slide in view changes, with the index being asked for. Cancelable: refusing it takes the decision and nothing moves, including a drag, which is put back on the slide the index still holds. See `handleScroll`.
+ * @event {HelixSelectEvent} helix-select - Fired before the slide in view changes, with the requested index. Cancelable: cancel it to keep the current slide. Nothing moves, and a drag returns to the slide the index still holds. See `handleScroll`.
  *
  * @csspart controls - The row of controls.
- * @csspart indicator - One of them, and a way to reach that slide.
- * @csspart indicator-current - The one for the slide showing, beside `indicator`.
- * @csspart indicators - The row of controls saying where the reader is.
+ * @csspart indicator - One indicator. Pressing it moves to its slide.
+ * @csspart indicator-current - The indicator for the slide in view, alongside `indicator`.
+ * @csspart indicators - The row of indicators that shows which slide is in view.
  * @csspart next - The control that moves to the next slide.
  * @csspart next-mark - The glyph on the next control.
  * @csspart previous - The control that moves to the previous slide.
@@ -42,11 +41,11 @@ import { type PropertyValues, type TemplateResult } from 'lit';
  * @csspart slide - The pane one slide is shown in, and the box the track snaps to.
  * @csspart track - The scroller the slides sit in.
  *
- * @cssproperty --carousel-gap - Space between slides. A sheet sets it and the component measures the run with it.
- * @cssproperty --carousel-pane - The size one pane is laid out at. A sheet sets it and the component measures the run with it.
- * @cssproperty --carousel-per-view - How many slides go across, written onto the track by the component so a sheet divides the track by the same number the positions are counted from. Read it rather than selecting on `per-view`, which cannot be enumerated without a ceiling. Under `per-view="auto"` the component writes nothing and the sheet declares it instead, so the same name answers in both modes. See `perView`.
- * @cssproperty --carousel-run-end - How far short of a whole pixel the run ends, on the last slide alone, for a sheet to take up as `margin-inline-end`. See `runEnd`.
- * @cssproperty --carousel-slide-min - The narrowest a slide may be laid out, which is what `per-view="auto"` fits the track with. A length, since the sheet divides by it. Unset is the whole track, which is one across.
+ * @cssproperty --carousel-gap - Space between slides. Your stylesheet sets it, and the component uses it to measure the run.
+ * @cssproperty --carousel-pane - The size of one pane. Your stylesheet sets it, and the component uses it to measure the run.
+ * @cssproperty --carousel-per-view - How many slides go across. The component writes it onto the track, so your stylesheet divides the track by the same number the component counts positions from. Read this property to follow `per-view`, because attribute selectors cannot cover every possible count. Under `per-view="auto"` the component writes nothing and your stylesheet declares it, so the same name works in both modes. See `perView`.
+ * @cssproperty --carousel-run-end - How far short of a whole pixel the run ends, set on the last slide only. Your stylesheet applies it as `margin-inline-end`. See `runEnd`.
+ * @cssproperty --carousel-slide-min - The narrowest a slide may be. `per-view="auto"` uses it to fit slides into the track. It must be a length, because the stylesheet divides by it. When unset, it is the whole track, which shows one slide across.
  */
 export declare class HelixHeadlessCarousel extends HelixElement {
     /**
@@ -93,7 +92,7 @@ export declare class HelixHeadlessCarousel extends HelixElement {
      */
     controls?: 'always' | 'auto' | 'none';
     /**
-     * Slide to start on, where nothing declared one.
+     * The slide to start on, used until `index` is set.
      */
     defaultIndex: number;
     /**
@@ -113,7 +112,7 @@ export declare class HelixHeadlessCarousel extends HelixElement {
     get index(): number;
     set index(next: number);
     /**
-     * What one indicator is called, with `{index}` filled in.
+     * The name of each indicator, with `{index}` filled in.
      *
      * **Every word the carousel speaks is a property**, so a page in another
      * language hears its own: only `label` was, and the controls around it
@@ -121,7 +120,7 @@ export declare class HelixHeadlessCarousel extends HelixElement {
      */
     indicatorLabel: string;
     /**
-     * What the row of indicators is called, with the carousel's `{label}` filled in.
+     * The name of the row of indicators, with the carousel's `{label}` filled in.
      */
     indicatorsLabel: string;
     /**
@@ -133,7 +132,7 @@ export declare class HelixHeadlessCarousel extends HelixElement {
     /** How many panes were drawn at the last update, to scroll when the first are. */
     private scrolledFor;
     /**
-     * Accessible name for the carousel.
+     * The carousel's name, read by screen readers.
      */
     label: string;
     /**
@@ -141,7 +140,7 @@ export declare class HelixHeadlessCarousel extends HelixElement {
      */
     loop: boolean;
     /**
-     * What the control that moves forward is called.
+     * The name of the control that moves to the next slide.
      */
     nextLabel: string;
     /**
@@ -229,24 +228,24 @@ export declare class HelixHeadlessCarousel extends HelixElement {
      */
     perView?: number | 'auto';
     /**
-     * What the control that moves back is called.
+     * The name of the control that moves to the previous slide.
      */
     previousLabel: string;
     /**
-     * What each slide is called, with `{index}` and `{count}` filled in.
+     * The name of each slide, with `{index}` and `{count}` filled in.
      */
     slideLabel: string;
     /**
-     * What a slide is, read out in place of its role: `aria-roledescription`,
-     * which is a word a reader hears and so a word to translate.
+     * The word screen readers announce in place of a slide's role, set as
+     * `aria-roledescription`. Translate it with the rest of your text.
      */
     slideRoleLabel: string;
     /**
-     * What the rotation control is called while it would start rotation.
+     * The name of the rotation control while rotation is stopped.
      */
     startLabel: string;
     /**
-     * And while it would stop it.
+     * The name of the rotation control while rotation is running.
      */
     stopLabel: string;
     /**
@@ -414,7 +413,7 @@ export declare class HelixHeadlessCarousel extends HelixElement {
      * the right, the left arrow is the one that moves on.
      */
     private readonly handleIndicatorKeydown;
-    /** Moves to a slide, wrapping only where `loop` says to. */
+    /** Moves to a slide. It wraps past either end only when `loop` is set. */
     goTo(index: number): void;
     /**
      * The leading padding the track keeps for a slide to draw its own edge in.

package/dist/chat/composer/chat-composer.d.ts

@@ -1,22 +1,19 @@
 import { HelixElement } from '@fusion.dev/helix-core';
 import { type PropertyValues, type TemplateResult } from 'lit';
 /**
- * @summary Where the reader writes their turn.
+ * @summary A field for writing a turn in a conversation.
  *
  * @description
- * **A separate element because it is separately replaceable.** A consumer with
- * attachments, slash commands or a model picker replaces the composer and keeps
- * the transcript, which is only possible if the two were never one component.
+ * The composer is a separate element so you can replace it. If you need
+ * attachments, slash commands, or a model picker, replace the composer and keep
+ * the transcript.
  *
- * **Enter sends and Shift+Enter opens a line, and it is configurable rather than
- * decided.** The convention is near-universal in messaging and near-inverted in
- * anything that is really a document editor, and a component that picks one
- * makes the other consumer reimplement the composer. `submit-on` takes `enter`
- * or `button`, and the second is what a long-form composer wants.
+ * By default, Enter sends and Shift+Enter starts a new line, the convention in
+ * messaging apps. Document editors mostly use the opposite, so `submit-on`
+ * takes `enter` or `button`. Use `button` for a long-form composer.
  *
- * The composer clears only when nobody refused the send, because a composer that
- * empties itself and then hears the request failed has thrown away the only copy
- * of what the reader wrote.
+ * The composer clears only when no listener cancels the send, so the text is
+ * kept when you cancel a send that failed.
  *
  * @since 0.1.0
  * @status stable
@@ -24,30 +21,30 @@ import { type PropertyValues, type TemplateResult } from 'lit';
  * @aliases Message box, Prompt input
  * @documentation https://fusion.dev/helix/components/chat
  *
- * @slot end - Under the field, beside the send control.
- * @slot start - Under the field, at the leading edge: attachments, a model picker.
+ * @slot end - Content under the field, beside the send button.
+ * @slot start - Content under the field at the leading edge, such as an attachment button or a model picker.
  *
- * @event {HelixSendEvent} helix-send - Fired when the reader offers their turn, and cancelable.
+ * @event {HelixSendEvent} helix-send - Fired when the user sends their turn, and cancelable.
  *
  * @csspart composer - The whole composer.
- * @csspart end - The trailing slot's box.
+ * @csspart end - The box around the `end` slot.
  * @csspart field - The text field.
- * @csspart mark - The glyph inside the send control.
- * @csspart send - The control that offers the turn.
- * @csspart start - The leading slot's box.
+ * @csspart mark - The icon inside the send button.
+ * @csspart send - The send button.
+ * @csspart start - The box around the `start` slot.
  * @csspart tools - The row under the field.
  */
 export declare class HelixHeadlessChatComposer extends HelixElement {
     /**
-     * Whether the composer refuses input, while a turn is in flight say.
+     * Whether the composer blocks input, such as while a turn is being sent.
      */
     disabled: boolean;
     /**
-     * Accessible name for the field.
+     * The field's name, read by screen readers.
      */
     label: string;
     /**
-     * Shown in an empty field.
+     * Placeholder text shown in an empty field.
      */
     placeholder: string;
     /**
@@ -57,11 +54,12 @@ export declare class HelixHeadlessChatComposer extends HelixElement {
      */
     rows: number;
     /**
-     * Label for the control that sends.
+     * Label for the send button.
      */
     sendLabel: string;
     /**
-     * What sends: pressing Enter, or only the control.
+     * What sends the turn: `enter` for the Enter key, or `button` for the send
+     * button only.
      *
      * `enter` is the messaging convention and makes Shift+Enter the line break.
      * `button` is what a composer holding several paragraphs wants, where Enter
@@ -69,7 +67,7 @@ export declare class HelixHeadlessChatComposer extends HelixElement {
      */
     submitOn: 'button' | 'enter';
     /**
-     * What the reader has written.
+     * The text the user has written.
      *
      * Read it, or set it to seed a draft.
      */
@@ -82,7 +80,7 @@ export declare class HelixHeadlessChatComposer extends HelixElement {
     /** What is in the field, whoever last wrote it. */
     private get text();
     /**
-     * Offers what is written, and reports whether it stood.
+     * Sends what is written, and returns whether the send went through.
      *
      * Public because a consumer's own send control is as likely to ask as this
      * element's is, and because a keyboard shortcut somewhere else on the page is

package/dist/chat/message/chat-message.d.ts

@@ -8,19 +8,16 @@ import { nothing, type PropertyValues, type TemplateResult } from 'lit';
  */
 export declare const FAILED_LABEL = "Not sent";
 /**
- * @summary One turn in a conversation, and what has happened to it.
+ * @summary One turn in a conversation, with its state, such as sending or failed.
  *
  * @description
- * **The states are the component.** Bubbles are paint; what a chat message has
- * to carry is whether it is on its way, arrived, still arriving, or failed, and
- * a failed message needs a retry that is a real action rather than a toast the
- * reader has to catch.
+ * A chat message carries its state: sending, arrived, streaming, or failed. A
+ * failed message has a retry control in the message, which fires `helix-send`.
  *
- * `streaming` is the state everything else is arranged around. A message
- * arriving token by token changes height on every frame, so it is marked
- * `aria-busy` while it arrives and announced once when it settles: a screen
- * reader reading a stream character by character is unusable, and announcing on
- * completion is the only version of this that works.
+ * `streaming` is the state the others are arranged around. A streaming message
+ * changes height on every frame, so it is marked `aria-busy` while it arrives
+ * and announced once when it settles. A screen reader cannot follow a stream
+ * read out character by character.
  *
  * @since 0.1.0
  * @status stable
@@ -28,35 +25,35 @@ export declare const FAILED_LABEL = "Not sent";
  * @aliases Message, Bubble, Turn
  * @documentation https://fusion.dev/helix/components/chat
  *
- * @slot - What was said.
- * @slot actions - What can be done with it: copy, retry, react.
- * @slot avatar - Who said it.
- * @slot indicator - The wait before the first token. Falls back to the typing
- * indicator, so slotting nothing is what this has always done.
- * @slot sources - What it was said from: citations, documents, a retrieved page.
+ * @slot - The turn's content.
+ * @slot actions - Controls for the turn, such as copy, retry, or react.
+ * @slot avatar - The author's avatar.
+ * @slot indicator - The indicator shown before the first token arrives.
+ * Defaults to the typing indicator.
+ * @slot sources - The turn's sources, such as citations, documents, or a retrieved page.
  *
- * @event {HelixSendEvent} helix-send - Fired when the reader asks to send a failed message again. Cancelable: a retry that stands puts the turn back on its way, and refusing it leaves the failure and the control offering it exactly where they were.
+ * @event {HelixSendEvent} helix-send - Fired when the user retries a failed message. Cancelable: if it is not canceled, the turn is sent again. Canceling it leaves the failure and the retry button as they were.
  *
- * @csspart actions - The controls offered on the turn, beside its time.
- * @csspart avatar - The leading slot's box.
- * @csspart body - What was said, and the line under it.
- * @csspart content - The consumer's own markup.
- * @csspart indicator - The default wait, drawn only when nothing is slotted over it.
- * @csspart mark - The status glyph beside a failure.
+ * @csspart actions - The controls on the turn, beside its time.
+ * @csspart avatar - The box around the `avatar` slot.
+ * @csspart body - The content and the line under it.
+ * @csspart content - Your own markup.
+ * @csspart indicator - The default indicator, drawn only when nothing is in the `indicator` slot.
+ * @csspart mark - The status icon beside a failure.
  * @csspart message - The whole turn.
- * @csspart meta - The line under a turn: its time, its state, and its controls.
- * @csspart retry - The control offered on a failed message.
- * @csspart sources - What the turn was drawn from, under it and outside the bubble.
- * @csspart state - What has happened to it, where that is worth saying.
- * @csspart time - When it was said.
+ * @csspart meta - The line under a turn, with its time, state, and controls.
+ * @csspart retry - The retry button on a failed message.
+ * @csspart sources - The turn's sources, under it and outside the bubble.
+ * @csspart state - The text that names the turn's state, when there is one to show.
+ * @csspart time - The turn's time.
  */
 export declare class HelixHeadlessChatMessage extends HelixElement {
     /**
-     * When it was said, as anything `Date` parses.
+     * The turn's time, in any format `Date` parses.
      */
     at: string;
     /**
-     * Who said it.
+     * The turn's author.
      *
      * Free text rather than a two-value union, because a conversation is not
      * always two-sided: a transcript with a system turn, a tool call and three
@@ -76,15 +73,15 @@ export declare class HelixHeadlessChatMessage extends HelixElement {
      */
     locale: string;
     /**
-     * Label for the control offered on a failed message.
+     * Label for the retry button on a failed message.
      */
     retryLabel: string;
     /**
-     * What to call each state, for a reader who cannot see it.
+     * The label shown while the message is sending.
      */
     sendingLabel: string;
     /**
-     * What has happened to it.
+     * The turn's state.
      *
      * Reflected, because every one of the four is a visual state and a stylesheet
      * has no other way to know. Absent is a settled message with nothing to

package/dist/chat/root/chat-root.d.ts

@@ -22,51 +22,33 @@ export interface ChatTurn {
 }
 declare const HelixHeadlessChat_base: (new (...args: any[]) => import("@fusion.dev/helix-core").CollectionElement) & typeof HelixElement;
 /**
- * @summary A conversation: the turns, and where the reader is in them.
+ * @summary A conversation's turns in a scrolling transcript that keeps the user's place.
  *
  * @description
- * **It has no opinion about where it sits.** A chat is asked for as a floating
- * button, a page, a palette, a sidebar, a modal and an inline block, and none
- * of those is a variant of a conversation: they are containers, and the
- * containers already exist. Nothing here is positioned, nothing has a backdrop,
- * and nothing owns a trigger. If a form factor needs a mode on this element,
- * the split is wrong.
+ * Chat has no positioning, no backdrop, and no trigger, so you can put it in
+ * any container, such as a page, a sidebar, a modal, or a floating panel.
  *
- * **Scroll ownership is the behavior everything else depends on.** A transcript
- * that grows wants to stay at the bottom, except when the reader has scrolled
- * up to read, where pinning is hostile. The rule: pin while the reader is
- * within `threshold` of the bottom, and let go the moment they leave it. A turn
- * growing under a pinned reader is not the reader leaving, so a streamed answer
- * is followed to its last line.
+ * The transcript stays pinned to the bottom, including while a streamed answer
+ * grows, until the user scrolls more than `threshold` away from it.
  *
- * **History loads upward, under a reader who does not move.** With `history`
- * set to `more`, reaching the top fires `helix-history`; the consumer sets
- * `loading` while it fetches and prepends the older turns, and the turn the
- * reader was looking at stays where it was on screen while the room above it
- * grows.
+ * With `history` set to `more`, reaching the top fires `helix-history`. Set
+ * `loading` while you fetch, then prepend the older turns. The turn the user
+ * was reading stays in place on screen.
  *
- * **A turn is announced once, when it settles**, and not by the log. A log
- * that is a live region reads what enters it, which is every token of a stream
- * where `aria-busy` is not honored, every page of history as it loads, and
- * every window of a long transcript as the reader scrolls through it. So the
- * log is `aria-live="off"`, and a status region of its own says each new turn
- * when it has finished arriving: never the reader's own words unless they
- * failed to send, never a turn loaded above the ones already there, and never
- * what was in the transcript when it opened.
+ * The log is `aria-live="off"`. A separate status region announces each new
+ * turn once, when it has finished arriving. It skips the user's own turns
+ * unless they failed to send, turns loaded as history, and the turns already
+ * there when the transcript opened.
  *
- * **Turns are markup children or data, not both.** Children serve whole from a
- * server and are what most conversations want. `turns` is for the transcript
- * too long to hold as elements: it is drawn a window at a time, measured as it
- * goes, and the log needs a block size of its own for that to mean anything.
+ * Pass the turns as children or as `turns` data. Do not use both. Children
+ * render from the server and suit most conversations. `turns` draws a long
+ * transcript one window at a time, so the log needs a block size of its own.
  *
- * **A fed turn is styled through this element, not its own.** Its message is
- * drawn in this shadow root, where `[author="me"]` cannot reach it, so every
- * fed turn's parts are forwarded as `message-*`, and the ones that change with
- * the turn a second time while it holds: `-mine` for a turn by `me`, and
- * `message-meta-failed`, `message-content-sending` and
- * `message-content-streaming` for its state. Every other author has the plain
- * names only, so a conversation styling each participant apart passes its
- * turns as children.
+ * A turn from `turns` is drawn in the chat's shadow root, so style it through
+ * the forwarded `message-*` parts. A turn by `me` also gets each part with
+ * `-mine` added, and the turn's state adds `message-meta-failed`,
+ * `message-content-sending`, and `message-content-streaming`. To style each
+ * participant differently, pass the turns as children.
  *
  * @since 0.1.0
  * @status stable
@@ -75,53 +57,53 @@ declare const HelixHeadlessChat_base: (new (...args: any[]) => import("@fusion.d
  * @documentation https://fusion.dev/helix/components/chat
  *
  * @slot - The turns.
- * @slot actions - Beside the header: what can be done to the conversation itself.
- * @slot composer - Below the transcript, where the reader writes.
- * @slot header - Above the transcript: what this conversation is.
- * @slot resume - The way back to the bottom, shown while the reader has scrolled away.
- * @slot status - Beside the composer: somebody typing, connection lost.
+ * @slot actions - Controls for the whole conversation, beside the header.
+ * @slot composer - The composer, below the transcript.
+ * @slot header - Content above the transcript that names the conversation.
+ * @slot resume - The control that returns to the bottom, shown while the user has scrolled away.
+ * @slot status - Status beside the composer, such as someone typing or a lost connection.
  *
- * @event {HelixBeforePinEvent} helix-before-pin - Fired when the reader pins or unpins the transcript by scrolling. Cancelable.
- * @event {HelixHistoryEvent} helix-history - Fired when the reader reaches the oldest turn while `history` is `more`, reporting where they are rather than asking.
- * @event {HelixSendEvent} helix-send - A turn offered from the composer, or a failed one asked to go again, dispatched inside and heard here because the conversation is what a consumer holds. Cancelable: refusing it takes the decision and nothing is sent.
+ * @event {HelixBeforePinEvent} helix-before-pin - Fired when the user pins or unpins the transcript by scrolling. Cancelable.
+ * @event {HelixHistoryEvent} helix-history - Fired when the user reaches the oldest turn while `history` is `more`. It reports the position and cannot be canceled.
+ * @event {HelixSendEvent} helix-send - Fired when the user sends a turn from the composer or retries a failed one. It is fired inside and handled here, so you can listen for it on the conversation. Cancelable: canceling it sends nothing and leaves the decision to you.
  *
  * @csspart actions - The controls for the conversation, at the header's trailing edge.
- * @csspart after - The room the turns below the window would take. Data only.
- * @csspart before - The room the turns above the window would take. Data only.
+ * @csspart after - The space the turns below the rendered ones would take. Only for turns from `turns`.
+ * @csspart before - The space the turns above the rendered ones would take. Only for turns from `turns`.
  * @csspart composer - The region the composer sits in.
  * @csspart empty - Shown when the conversation has no turns.
  * @csspart header - The region above the transcript.
- * @csspart history - Shown at the top of the transcript while older turns are on their way.
- * @csspart live - Where each settled turn is said, for a reader who cannot see it arrive.
- * @csspart loading - Shown while the history is still on its way.
- * @csspart log - The transcript, which is the thing that scrolls.
- * @csspart message - A turn fed as data: the message drawn for it, forwarded whole.
- * @csspart message-actions - The controls offered on a fed turn, beside its time.
- * @csspart message-avatar - A fed turn's leading slot's box.
- * @csspart message-avatar-mine - The leading slot's box on a fed turn by `me`.
- * @csspart message-body - What a fed turn said, and the line under it.
- * @csspart message-body-mine - What a fed turn by `me` said, and the line under it.
- * @csspart message-content - A fed turn's text.
- * @csspart message-content-mine - The text of a fed turn by `me`.
- * @csspart message-content-sending - A fed turn's text while it is `sending`.
- * @csspart message-content-streaming - A fed turn's text while it is `streaming`.
- * @csspart message-indicator - A fed turn's default wait.
- * @csspart message-mark - The status glyph beside a fed turn's failure.
- * @csspart message-meta - The line under a fed turn: its time, its state, and its controls.
- * @csspart message-meta-failed - The line under a fed turn that `failed`, which says so.
- * @csspart message-meta-mine - The line under a fed turn by `me`.
- * @csspart message-mine - A fed turn by `me`: the message drawn for it.
- * @csspart message-retry - The control offered on a fed turn that failed.
- * @csspart message-sources - What a fed turn was drawn from.
- * @csspart message-state - What has happened to a fed turn, where that is worth saying.
- * @csspart message-time - When a fed turn was said.
- * @csspart resume - The affordance offered while the reader is away from the bottom.
- * @csspart status - The status region, which is not part of the log.
- * @csspart turn - One turn fed as data, around the message drawn for it.
+ * @csspart history - Shown at the top of the transcript while older turns load.
+ * @csspart live - The region where screen readers announce each turn once it has arrived.
+ * @csspart loading - Shown while the history loads.
+ * @csspart log - The transcript, which scrolls.
+ * @csspart message - The message drawn for a turn from `turns`, forwarded whole.
+ * @csspart message-actions - The controls on a turn from `turns`, beside its time.
+ * @csspart message-avatar - The avatar box of a turn from `turns`.
+ * @csspart message-avatar-mine - The avatar box of a turn from `turns` by `me`.
+ * @csspart message-body - The content of a turn from `turns`, and the line under it.
+ * @csspart message-body-mine - The content of a turn from `turns` by `me`, and the line under it.
+ * @csspart message-content - The text of a turn from `turns`.
+ * @csspart message-content-mine - The text of a turn from `turns` by `me`.
+ * @csspart message-content-sending - The text of a turn from `turns` while it is `sending`.
+ * @csspart message-content-streaming - The text of a turn from `turns` while it is `streaming`.
+ * @csspart message-indicator - The default indicator of a turn from `turns`.
+ * @csspart message-mark - The status icon beside a failed turn from `turns`.
+ * @csspart message-meta - The line under a turn from `turns`, with its time, state, and controls.
+ * @csspart message-meta-failed - The line under a turn from `turns` that `failed`, which shows the failure.
+ * @csspart message-meta-mine - The line under a turn from `turns` by `me`.
+ * @csspart message-mine - The message drawn for a turn from `turns` by `me`.
+ * @csspart message-retry - The retry button on a failed turn from `turns`.
+ * @csspart message-sources - The sources of a turn from `turns`.
+ * @csspart message-state - The state text of a turn from `turns`, when there is one to show.
+ * @csspart message-time - The time of a turn from `turns`.
+ * @csspart resume - The control shown while the user is scrolled away from the bottom.
+ * @csspart status - The status region, outside the log.
+ * @csspart turn - The wrapper around the message drawn for one turn from `turns`.
  */
 export declare class HelixHeadlessChat extends HelixHeadlessChat_base {
     /**
-     * Nothing is assigned by name, so the turns land in the log and the rest does not.
+     * Slots are assigned manually, so only the turns go into the log.
      *
      * The messages are ordinary children a consumer writes with no `slot`, and a
      * `role="log"` whose turns are somewhere else is a log of nothing. Manual
@@ -133,7 +115,8 @@ export declare class HelixHeadlessChat extends HelixHeadlessChat_base {
     /** How tall a turn is assumed to be before it has been drawn, in pixels. */
     static readonly ESTIMATE = 72;
     /**
-     * Whether to open pinned, where nothing declared it.
+     * Whether the transcript opens pinned to the bottom, when `pinned` is not
+     * set.
      *
      * `default-pinned="false"` opens away from the bottom. A plain boolean
      * attribute could not say that: it is true by being there, whatever it holds,
@@ -141,7 +124,7 @@ export declare class HelixHeadlessChat extends HelixHeadlessChat_base {
      */
     defaultPinned: boolean;
     /**
-     * Whether there are older turns than the ones here, and whether they are coming.
+     * Whether there are older turns to load, and whether they are loading.
      *
      * `more` makes reaching the top fire `helix-history`, once per arrival;
      * `loading` draws `history-text` above the oldest turn and fires nothing; empty
@@ -150,11 +133,11 @@ export declare class HelixHeadlessChat extends HelixHeadlessChat_base {
      */
     history: '' | 'loading' | 'more';
     /**
-     * What to say while older turns are on their way.
+     * The text shown while older turns load.
      */
     historyText: string;
     /**
-     * Accessible name for the conversation.
+     * The conversation's name, read by screen readers.
      */
     label: string;
     /**