@fusion.dev/helix-headless 0.105.0 → 0.107.0

package/dist/notifications/notification/notification.d.ts

@@ -3,32 +3,24 @@ import { nothing, type PropertyValues, type TemplateResult } from 'lit';
 import '../../format-date/index.js';
 declare const HelixHeadlessNotification_base: (new (...args: any[]) => import("@fusion.dev/helix-core").DismissibleElement) & typeof HelixElement;
 /**
- * @summary One thing that happened, which a reader may not have seen yet.
+ * @summary A single notification about something that happened, marked read or unread.
  *
  * @description
- * A notification is a toast that did not go away. `Toast` is deliberately the
- * opposite of this: a live region whose items carry a `duration` and whose root
- * never creates or destroys anything. What makes this its own family is the
- * state each item carries rather than the arrangement it sits in: read and
- * unread, a timestamp that has to stay correct, and an action a reader can take
- * later.
+ * A notification is a toast that stays. `Toast` is a live region whose items
+ * have a `duration`. A notification carries state instead: read or unread, a
+ * timestamp that stays correct, and an action you can take later.
  *
- * **The row is a label, a caption under it, and one trailing column that holds
- * either the time or the controls.** A feed is scanned rather than read, so the
- * thing that happened gets the first line on its own and everything qualifying
- * it goes under. The time and the controls occupy the same place because a
- * reader wants exactly one of them at a time: the time while they are scanning,
- * and what they can do about it once they have stopped on a row.
+ * The row has a label, a caption under it, and one trailing column. The label
+ * gets the first line on its own, so a feed is quick to scan. The trailing
+ * column shows either the time or the controls: the time while you scan, and
+ * the controls once you stop on a row.
  *
- * **The timestamp is `FormatDate`**, which is where the reading, the `<time
- * datetime>` and the shared timer now live. It was implemented here, and a
- * component that formats a date is not a fact about notifications: Chat wanted
- * the same thing and had its own copy of half of it.
+ * `FormatDate` renders the timestamp, including the readable text, the
+ * `<time datetime>` element, and the shared timer that keeps it current.
  *
- * **Read state is reported, not invented.** Marking something read is usually a
- * round trip, and a component that flips its own state and then hears the
- * request failed has told the reader something untrue. `helix-read` is
- * cancelable, and a `read` set by the consumer makes this element defer entirely.
+ * Read state is reported to you. Marking a notification read is usually a round
+ * trip to a server, so `helix-read` is cancelable, and when you set `read`
+ * yourself the element leaves it to you.
  *
  * @since 0.1.0
  * @status stable
@@ -36,35 +28,35 @@ declare const HelixHeadlessNotification_base: (new (...args: any[]) => import("@
  * @aliases Notification item, Inbox item
  * @documentation https://fusion.dev/helix/components/notifications
  *
- * @slot - What happened, in the consumer's own markup.
- * @slot actions - What a reader can do about it, under the words it is about. Drawn always
- * rather than on hover, because an action is the point of the row and not chrome around it.
- * @slot description - A second line qualifying it, quieter than the first. A bare
- * slot rather than a box, so an item without one pays nothing for it; style it
- * through `::slotted()`.
- * @slot detail - A block belonging to the row rather than a line about it: a quoted
- * comment, a status moving from one value to another, a preview. Unlike `description` nothing
- * here sets a size or an ink, because whatever fills it usually brings its own.
- * @slot dismiss - Replaces the glyph inside the dismiss control, which is drawn
- * only where the row is `dismissible`.
+ * @slot - What happened, in your own markup.
+ * @slot actions - Actions the user can take, shown under the text. They are always visible,
+ * because acting on the notification is the purpose of the row.
+ * @slot description - A second, quieter line with more detail. It is a bare slot
+ * with no wrapping box, so an item without a description costs nothing. Style it
+ * with `::slotted()`.
+ * @slot detail - A block of content in the row, such as a quoted comment, a status
+ * change from one value to another, or a preview. It sets no text size or color, because
+ * its content usually brings its own.
+ * @slot dismiss - Replaces the icon inside the dismiss control, which is drawn
+ * only when the row is `dismissible`.
  * @slot media - An avatar or icon identifying who or what it came from.
  *
- * @event {HelixDismissEvent} helix-dismiss - Fired when a reader asks to remove it, and cancelable.
- * @event {HelixReadEvent} helix-read - Fired when the item is marked read or unread, and cancelable.
+ * @event {HelixDismissEvent} helix-dismiss - Fired when the user dismisses the notification. Cancelable.
+ * @event {HelixReadEvent} helix-read - Fired when the notification is marked read or unread. Cancelable.
  *
  * @csspart actions - The trailing slot's box.
  * @csspart body - The label and the caption together.
- * @csspart controls - The actions and the dismiss, which replace the time.
- * @csspart dismiss - The control that removes it.
- * @csspart dismiss-mark - The glyph on that control, where none is slotted.
+ * @csspart controls - The actions and the dismiss control, shown in place of the time.
+ * @csspart dismiss - The control that dismisses the notification.
+ * @csspart dismiss-mark - The icon on the dismiss control, when no icon is slotted.
  * @csspart item - The whole notification.
  * @csspart label - What happened, on the first line.
  * @csspart media - The leading slot's box.
- * @csspart time - When it happened, read the way a person reads one.
+ * @csspart time - When it happened, formatted for people to read.
  * @csspart trailing - The column holding the time and the controls.
  *
  * @cssstate actions - While the actions slot holds something, so the words above make room for it.
- * @cssstate controls - While it can be dismissed, so the time makes way for the control under a pointer.
+ * @cssstate controls - The item can be dismissed, so the time gives way to the dismiss control under a pointer.
  * @cssstate read - While it has been read.
  */
 export declare class HelixHeadlessNotification extends HelixHeadlessNotification_base {
@@ -78,7 +70,7 @@ export declare class HelixHeadlessNotification extends HelixHeadlessNotification
      */
     at: string;
     /**
-     * State to open with, where nothing declared one.
+     * Whether the notification starts as read, used until `read` is set.
      */
     defaultRead: boolean;
     /**
@@ -88,7 +80,7 @@ export declare class HelixHeadlessNotification extends HelixHeadlessNotification
      */
     locale: string;
     /**
-     * Whether the reader has seen it.
+     * Whether the notification has been read.
      *
      * Set it and this element defers: a reader's click fires `helix-read` and
      * changes nothing until a new value arrives. `default-read` seeds a state
@@ -112,7 +104,8 @@ export declare class HelixHeadlessNotification extends HelixHeadlessNotification
     readonly isNotification = true;
     private readState;
     /**
-     * Asks to be marked read, and reports whether the request stood.
+     * Requests that the notification be marked read, and returns whether the
+     * change was applied.
      *
      * Public because a consumer's own control is as likely to ask as this
      * element's own markup is, and because a list marking everything read has to

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

@@ -4,25 +4,22 @@ import type { HelixHeadlessNotificationGroup } from '../group/notification-group
 import type { HelixHeadlessNotification } from '../notification/notification.js';
 declare const HelixHeadlessNotifications_base: (new (...args: any[]) => import("@fusion.dev/helix-core").CollectionElement) & typeof HelixElement;
 /**
- * @summary A feed a reader comes back to, made of notifications they may not have seen.
+ * @summary A feed of notifications, each marked read or unread.
  *
  * @description
- * **Slotted children rather than a data property.** A notification is a small
- * piece of somebody's own markup, with an avatar and a link and a button in it,
- * and there are tens of them rather than thousands, so writing them out lets an
- * item hold anything.
+ * Notifications are slotted children. Each one is your own markup, with an
+ * avatar, a link, or a button in it. Feeds usually hold tens of items, so
+ * writing them out lets an item hold anything.
  *
- * **This does not virtualize, and it cannot.** Windowing needs the list to own
- * the data, and here the consumer owns it: N notifications is N elements by
- * construction. A feed that really does hold thousands wants a data table with a
- * custom cell, and this component will not grow into one.
+ * The list does not virtualize. Windowing needs the list to own the data, and
+ * here you own it, so N notifications are N elements. For a feed of thousands,
+ * use a data table with a custom cell.
  *
- * **Read state is reported, never invented.** Marking read is usually a round
- * trip: this element asks its items and each item asks the consumer, so a
- * refused `helix-read` leaves everything alone and a consumer who owns `read`
- * sees nothing change until they say so. `unread` is derived from the items and
- * written to an attribute, so a stylesheet and a badge can both read it without
- * either of them counting.
+ * Read state is reported to you. Marking read goes from the root to the item
+ * and from the item to you, so a canceled `helix-read` changes nothing, and if
+ * you own `read`, nothing changes until you set it. `unread` is derived from
+ * the items and written to an attribute, so a stylesheet and a badge can both
+ * use it without counting.
  *
  * @since 0.1.0
  * @status stable
@@ -34,15 +31,15 @@ declare const HelixHeadlessNotifications_base: (new (...args: any[]) => import("
  * @slot footer - Below the list, for a link to everything.
  * @slot header - Above the list, for a title and the mark-all control.
  *
- * @event {HelixDismissEvent} helix-dismiss - A row asking to be removed, dispatched by the row and heard here because the feed is what a consumer holds. Cancelable: refusing it takes the decision and the row stays.
- * @event {HelixReadEvent} helix-read - Fired by an item, and by this element when everything is marked read. Cancelable.
+ * @event {HelixDismissEvent} helix-dismiss - Fired when the user dismisses a row. The row dispatches it, and you can listen for it on the feed. Cancelable: cancel it to keep the row.
+ * @event {HelixReadEvent} helix-read - Fired by an item when it is marked read or unread, and by the feed when everything is marked read. Cancelable.
  *
  * @csspart empty - Shown when there is nothing in the feed.
  * @csspart footer - The region below the list.
  * @csspart header - The region above the list.
  * @csspart list - The list itself.
- * @csspart live - The empty and loading lines again, in a region a screen reader hears when they change. Visually hidden in the styled tier.
- * @csspart loading - Shown while the feed is still on its way.
+ * @csspart live - A copy of the empty and loading messages, in a live region that screen readers announce when they change. Visually hidden in the styled tier.
+ * @csspart loading - Shown while the feed is loading.
  * @csspart mark-all - The control that marks everything read.
  *
  * @cssstate media - While a notification in the list holds something in its media slot, so every row keeps that column.
@@ -59,7 +56,7 @@ export declare class HelixHeadlessNotifications extends HelixHeadlessNotificatio
      */
     static shadowRootOptions: ShadowRootInit;
     /**
-     * Accessible name for the feed.
+     * The feed's name, read by screen readers.
      */
     label: string;
     /**
@@ -67,7 +64,7 @@ export declare class HelixHeadlessNotifications extends HelixHeadlessNotificatio
      */
     markAll: boolean;
     /**
-     * Label for that control.
+     * Label for the mark-all control.
      */
     markAllLabel: string;
     /**
@@ -102,7 +99,8 @@ export declare class HelixHeadlessNotifications extends HelixHeadlessNotificatio
      */
     get items(): HelixHeadlessNotification[];
     /**
-     * What the list slot is given: the rows and the groups, as written.
+     * The content assigned to the list slot: the rows and the groups, in the
+     * order they are written.
      *
      * Not `items`, which reaches through a group to the rows inside it. Assigning
      * those would lift them out of the group that is arranging them and hand the
@@ -118,7 +116,7 @@ export declare class HelixHeadlessNotifications extends HelixHeadlessNotificatio
      */
     get groups(): HelixHeadlessNotificationGroup[];
     /**
-     * Folds every group that can fold, and reports how many actually moved.
+     * Collapses every collapsible group, and returns how many changed.
      *
      * **A command, not a second place the state lives.** A group owns whether it
      * is folded; this asks all of them at once. The alternative, a property on the
@@ -141,7 +139,7 @@ export declare class HelixHeadlessNotifications extends HelixHeadlessNotificatio
      */
     foldEveryGroup(folded?: boolean): number;
     /**
-     * Marks every unread item read, and reports how many actually moved.
+     * Marks every unread item read, and returns how many changed.
      *
      * **Through each item's own request rather than by writing its property**,
      * which is what makes one refusal refuse one item: a consumer who owns some

package/dist/number-input/root/number-input-root.d.ts

@@ -2,34 +2,27 @@ import { AriaForwardController, HelixFormElement } from '@fusion.dev/helix-core'
 import { nothing, type PropertyValues, type TemplateResult } from 'lit';
 declare const HelixHeadlessNumberInput_base: (new (...args: any[]) => import("@fusion.dev/helix-core").MixinControllerValueInterface) & (new (...args: any[]) => import("@fusion.dev/helix-core").MixinFieldInterface) & typeof HelixFormElement;
 /**
- * @summary A number a reader types or steps to.
+ * @summary A field for a number, typed or changed with step buttons.
  *
  * @description
- * **A family rather than `Input`'s `type="number"`.** It renders two buttons,
- * binds four keys `Input` does not, and owns clamping and stepping, so it is an
- * alternative and not a variant.
+ * A separate family from `Input`'s `type="number"`. It renders two buttons,
+ * binds four keys `Input` does not, and handles clamping and stepping.
  *
- * **The field is `type="text"` with `inputmode="decimal"`, and that is a
- * measurement.** Asked of a real browser, `type=number` fails three ways this
- * control cannot live with:
+ * The field is `type="text"` with `inputmode="decimal"`. Tested in a real
+ * browser, `type="number"` fails in three ways:
+ * - Typing `12e` gives a `.value` of `""`, so the element cannot see what you
+ *   typed. A `type="text"` field keeps `"12e"`.
+ * - The mouse wheel over a focused field changes the value, for example from 5
+ *   to 4, when you only meant to scroll the page.
+ * - `selectionStart` is `null`, so the caret cannot be managed.
  *
- * ```
- * typed "12e" into type=number  → .value === ""
- * focused, wheeled over it      → 5 became 4
- * selectionStart on type=number → null
- * same keystrokes into type=text → .value === "12e"
- * ```
+ * `inputmode="decimal"` keeps the numeric keypad on phones.
  *
- * The first is fatal alone: the element cannot see what the reader typed. The
- * second changes a value because a page scrolled past. The third means the
- * caret cannot be managed at all. `inputmode` keeps the phone keypad, which is
- * the one thing `type=number` was giving.
- *
- * Validity is still the platform's, through `min`, `max` and `step` mirrored
+ * Validity still comes from the platform: `min`, `max`, and `step` are mirrored
  * onto the host's own `setValidity`.
  *
- * **Stepping is separate from typing**, so a reader mid-way through a number is
- * not corrected under their hands.
+ * Stepping is separate from typing, so a number is not corrected while you type
+ * it.
  *
  * @since 0.1.0
  * @status stable
@@ -37,31 +30,31 @@ declare const HelixHeadlessNumberInput_base: (new (...args: any[]) => import("@f
  * @aliases NumberField, Stepper, InputNumber
  * @documentation https://fusion.dev/helix/components/number-input
  *
- * @slot end - After it.
- * @slot start - Before the number, for a unit or an icon.
+ * @slot end - Content after the number, such as a unit.
+ * @slot start - Content before the number, such as a unit or an icon.
  *
- * @event {Event} change - Relayed from the field once the reader has finished.
- * @event {HelixBeforeChangeEvent} helix-before-change - Fired as the value changes, and cancelable.
- * @event {Event} input - Announced once the value has moved.
+ * @event {Event} change - The user finished changing the value. Relayed from the native field.
+ * @event {HelixBeforeChangeEvent} helix-before-change - The value is about to change. Cancelable: cancel it to keep the current value.
+ * @event {Event} input - The value changed.
  *
- * @csspart control - The field itself.
- * @csspart decrement - The control that steps down.
- * @csspart decrement-mark - The glyph on the step down control.
- * @csspart feedback - What is wrong with it.
- * @csspart field - The box holding everything.
- * @csspart hint - Help under the field, while nothing is wrong.
- * @csspart increment - The control that steps up.
- * @csspart increment-mark - The glyph on the step up control.
- * @csspart label - The name over the field, which is also the scrub grip.
+ * @csspart control - The input that holds the number.
+ * @csspart decrement - The button that steps the value down.
+ * @csspart decrement-mark - The icon on the step down button.
+ * @csspart feedback - The message that says what is wrong.
+ * @csspart field - The box that holds the whole control.
+ * @csspart hint - Help text under the field, shown while there is no feedback.
+ * @csspart increment - The button that steps the value up.
+ * @csspart increment-mark - The icon on the step up button.
+ * @csspart label - The label above the field. It is also the grip you drag when `scrub` is set.
  *
- * @cssstate invalid - While there is feedback to show: the platform's verdict, or the consumer's `feedback`.
+ * @cssstate invalid - The control has an error to show, from the browser's validation or from your `feedback`.
  */
 export declare class HelixHeadlessNumberInput extends HelixHeadlessNumberInput_base {
     protected readonly aria: AriaForwardController;
     /** Typed or dragged, so every edit is announced. See `announcesInput`. */
     protected readonly announcesInput = true;
     /**
-     * What the browser may autofill here, as one of the platform's own tokens.
+     * What the browser may autofill, as an HTML `autocomplete` token.
      *
      * Empty leaves the attribute off, which is the browser's default and is what
      * lets autofill work at all. Hardcoding `off` here is what stops a reader
@@ -70,7 +63,8 @@ export declare class HelixHeadlessNumberInput extends HelixHeadlessNumberInput_b
      */
     autocomplete: string;
     /**
-     * What a reader is told when the field holds something that is not a number.
+     * The message the browser shows when the field holds something that is not a
+     * number.
      *
      * **Every sentence a control raises in the browser's bubble is a property**,
      * named for the validity flag it reports, so a form in another language
@@ -79,15 +73,15 @@ export declare class HelixHeadlessNumberInput extends HelixHeadlessNumberInput_b
      */
     badInputMessage?: string;
     /**
-     * Accessible name for the control that steps down.
+     * The name of the step down button, read by screen readers.
      */
     decrementLabel: string;
     /**
-     * Accessible name for the control that steps up.
+     * The name of the step up button, read by screen readers.
      */
     incrementLabel: string;
     /**
-     * How far `PageUp` and `PageDown` move.
+     * How many steps `PageUp` and `PageDown` move.
      *
      * Ten steps, which is the convention every spinner on the platform follows,
      * and a property because ten of a step of `0.01` is a hundredth and rarely
@@ -95,13 +89,13 @@ export declare class HelixHeadlessNumberInput extends HelixHeadlessNumberInput_b
      */
     largeStep?: number;
     /**
-     * Largest value the reader may reach.
+     * The largest value allowed.
      *
      * Absent has no ceiling.
      */
     max?: number;
     /**
-     * Smallest value the reader may reach.
+     * The smallest value allowed.
      *
      * Absent has no floor.
      */
@@ -113,19 +107,21 @@ export declare class HelixHeadlessNumberInput extends HelixHeadlessNumberInput_b
      */
     placeholder: string;
     /**
-     * What a reader is told when the number is above `max`, with `{max}` filled in.
+     * The message the browser shows when the number is above `max`, with `{max}`
+     * filled in.
      */
     rangeOverflowMessage?: string;
     /**
-     * What a reader is told when the number is below `min`, with `{min}` filled in.
+     * The message the browser shows when the number is below `min`, with `{min}`
+     * filled in.
      */
     rangeUnderflowMessage?: string;
     /**
-     * Whether the field refuses input while still submitting its value.
+     * Prevents editing. The value is still submitted with the form.
      */
     readOnly: boolean;
     /**
-     * Whether a grip is shown that changes the value when it is dragged.
+     * Makes the label a grip that changes the value when it is dragged.
      *
      * The label is what is dragged, so this adds no chrome at all. Still opt-in,
      * because it changes what a press on the label does and a reader who drags
@@ -173,10 +169,10 @@ export declare class HelixHeadlessNumberInput extends HelixHeadlessNumberInput_b
      * refused step, or one pinned at a bound, finished nothing.
      */
     private land;
-    /** One step up, or `PageUp`'s larger one. */
+    /** Steps the value up, by `largeStep` steps when `large` is set. */
     stepUp(large?: boolean): void;
     /**
-     * Steps the value down, by `largeStep` when `large` is set.
+     * Steps the value down, by `largeStep` steps when `large` is set.
      *
      * The same path a press of the down arrow takes, so a consumer driving this
      * from their own control gets the clamping and the announcement rather than
@@ -278,7 +274,7 @@ export declare class HelixHeadlessNumberInput extends HelixHeadlessNumberInput_b
      * message is what a native spinner would have said.
      */
     private sync;
-    /** Puts the caret in the field, the way a label pointing at one would. */
+    /** Puts the cursor in the field. */
     focus(options?: FocusOptions): void;
     /** Selects the number, so typing replaces it. */
     select(): void;

package/dist/object-inspector/root/object-inspector-root.d.ts

@@ -14,44 +14,32 @@ interface Row {
     value: unknown;
 }
 /**
- * @summary A value read as a tree: collapse what you do not need, count what
- * you collapsed, copy the part you do.
+ * @summary A structured value shown as a tree, where you can close branches,
+ * see how many entries each holds, and copy any part.
  *
  * @description
- * What a developer-facing product shows constantly is a structured value: an
- * API response, a config, a row's raw record. As text in a code block, a reader
- * scrolls a wall of JSON and cannot put away the branch they do not care about;
- * as a Tree, every node is a label and a string reads the same as a number. This
- * reads the value and draws each entry with its type visible.
+ * Object Inspector shows a structured value, such as an API response, a config,
+ * or a raw record, as a read-only tree with each entry's type visible.
  *
- * **It reads and never edits.** An inspector that edits is a different
- * component, with validation, undo and a model of what changed, and the reading
- * one is what is wanted.
+ * Pass the object to `value`, or name a `<script type="application/json">` by
+ * id with `for`, the same source `VirtualList` and the charts read. JSON text
+ * works with server rendering and with React hydration, which skips object
+ * properties. `value` wins when both are set.
  *
- * **The data is text in the page or a property.** `for` names a
- * `<script type="application/json">` by id, the channel `VirtualList` and the
- * charts already read: it survives a server, which has attributes and no
- * children, and React's hydration, which skips object properties. `value` is
- * there for a page that already holds the object, and wins when both are set.
+ * The tree is one tab stop. Up and Down move between rows, Right opens a branch
+ * or moves into it, Left closes it or moves to its parent, and Home and End
+ * move to the first and last rows. Focus stays on the tree, and
+ * `aria-activedescendant` marks the active row. Each row carries its real
+ * level, position, and set size, including in a windowed tree.
  *
- * **One tab stop, and the rows are reached with the arrow keys**, the tree
- * pattern: Up and Down move, Right opens a branch or enters it, Left closes it or
- * goes to its parent, Home and End go to the ends. The tree keeps focus and
- * points at the active row with `aria-activedescendant`, which is what lets a
- * windowed tree drop rows from the page without dropping focus with them. Each
- * row carries its real level, position and set size, so a reader on a windowed
- * row hears where it is in the value rather than in the slice drawn.
+ * The copy button copies the active row, a branch as JSON and a string as its
+ * text. So do Command+C and Control+C while the tree has focus and no text is
+ * selected. The button sits beside the tree, because assistive technology
+ * cannot reliably reach a button inside a tree item.
  *
- * **Copying takes the active row**, as JSON for a branch and as itself for a
- * string, from the copy button or from Command or Control with C while the tree
- * has focus and nothing is selected. The button sits beside the tree rather than in each row, where a
- * button would be an interactive control inside a tree item, which assistive
- * technology cannot reach reliably.
- *
- * **`windowed` draws only the rows in view**, for a value of thousands of
- * entries, through the same controller `VirtualList` and `DataTable` use. The
- * box has to have a height for that to mean anything, which the styled tier
- * gives it and a headless consumer has to.
+ * `windowed` draws only the rows in view, for values with thousands of entries.
+ * The box needs a height for windowing to work. The styled tier sets one, and
+ * in the headless tier you set it yourself.
  *
  * @since 0.1.0
  * @status stable
@@ -61,48 +49,48 @@ interface Row {
  *
  * @event {HelixCopyEvent} helix-copy - A value was put on the clipboard, from the copy button or the keyboard.
  *
- * @csspart after - The room the rows after the window would take, when windowed.
- * @csspart before - The room the rows before the window would take, when windowed.
+ * @csspart after - The space the rows below the drawn rows would take, when `windowed` is set.
+ * @csspart before - The space the rows above the drawn rows would take, when `windowed` is set.
  * @csspart boolean - A `true` or `false`.
  * @csspart copy - The copy button, which copies the active row.
- * @csspart copy-button - The inner button.
- * @csspart copy-mark - The clipboard glyph, and the confirmation that replaces it.
- * @csspart copy-tooltip - The bubble, forwarded from the tooltip inside.
- * @csspart copy-tooltip-arrow - The point, resting against the trigger.
- * @csspart copy-tooltip-arrow-bottom - The point while the bubble is below the copy button, so on its top edge, beside `copy-tooltip-arrow`.
- * @csspart copy-tooltip-arrow-left - The point while the bubble is left of the copy button, so on its right edge, beside `copy-tooltip-arrow`.
- * @csspart copy-tooltip-arrow-right - The point while the bubble is right of the copy button, so on its left edge, beside `copy-tooltip-arrow`.
- * @csspart copy-tooltip-arrow-top - The point while the bubble is above the copy button, so on its bottom edge, beside `copy-tooltip-arrow`.
- * @csspart copy-tooltip-bottom - The bubble while it is below the copy button, beside `copy-tooltip`.
- * @csspart copy-tooltip-left - The bubble while it is left of the copy button, beside `copy-tooltip`.
- * @csspart copy-tooltip-right - The bubble while it is right of the copy button, beside `copy-tooltip`.
- * @csspart copy-tooltip-top - The bubble while it is above the copy button, beside `copy-tooltip`.
- * @csspart count - How many entries a branch holds.
+ * @csspart copy-button - The button inside the copy control.
+ * @csspart copy-mark - The clipboard icon, and the confirmation icon that replaces it.
+ * @csspart copy-tooltip - The tooltip, forwarded from the copy button's tooltip.
+ * @csspart copy-tooltip-arrow - The tooltip's arrow, pointing at the copy button.
+ * @csspart copy-tooltip-arrow-bottom - The arrow while the tooltip is below the copy button, on the tooltip's top edge. Set alongside `copy-tooltip-arrow`.
+ * @csspart copy-tooltip-arrow-left - The arrow while the tooltip is left of the copy button, on the tooltip's right edge. Set alongside `copy-tooltip-arrow`.
+ * @csspart copy-tooltip-arrow-right - The arrow while the tooltip is right of the copy button, on the tooltip's left edge. Set alongside `copy-tooltip-arrow`.
+ * @csspart copy-tooltip-arrow-top - The arrow while the tooltip is above the copy button, on the tooltip's bottom edge. Set alongside `copy-tooltip-arrow`.
+ * @csspart copy-tooltip-bottom - The tooltip while it is below the copy button. Set alongside `copy-tooltip`.
+ * @csspart copy-tooltip-left - The tooltip while it is left of the copy button. Set alongside `copy-tooltip`.
+ * @csspart copy-tooltip-right - The tooltip while it is right of the copy button. Set alongside `copy-tooltip`.
+ * @csspart copy-tooltip-top - The tooltip while it is above the copy button. Set alongside `copy-tooltip`.
+ * @csspart count - The number of entries a branch holds.
  * @csspart frame - The tree and the copy button beside it.
- * @csspart header - The bar carrying the label, where there is one.
+ * @csspart header - The bar that holds the label, when there is one.
  * @csspart key - A property name or an array index.
  * @csspart label - The label.
  * @csspart null - A `null`.
  * @csspart number - A number.
- * @csspart row - One entry, a tree item.
- * @csspart row-active - The entry the keyboard is on, beside `row`.
+ * @csspart row - One entry, as a tree item.
+ * @csspart row-active - The entry the keyboard is on. Set alongside `row`.
  * @csspart string - A string, in quotes.
- * @csspart summary - The brackets standing for a branch's contents.
- * @csspart toggle - The caret on a branch: down when open, across when closed.
- * @csspart tree - The tree, the one thing focus lands on.
+ * @csspart summary - The brackets that stand for a branch's contents.
+ * @csspart toggle - The caret on a branch. It points down when the branch is open and sideways when it is closed.
+ * @csspart tree - The tree, which is the element that receives focus.
  *
  * @cssproperty --object-inspector-level - How deep a row is, from 0 at the root, for indenting it.
  */
 export declare class HelixHeadlessObjectInspector extends HelixElement {
     /**
-     * What the copy control is called on a row with a key, with the key as
-     * `{name}`.
+     * The copy button's accessible name on a row with a key, with the key filled
+     * in as `{name}`.
      *
      * **Every word the inspector speaks is a property**, so a page in another
      * language hears its own rather than English around its own keys.
      */
     copyLabel: string;
-    /** What the copy control is called where there is no key, on the value itself. */
+    /** The copy button's accessible name on a row without a key, such as the root. */
     copyValueLabel: string;
     /**
      * How many levels start open.
@@ -126,7 +114,7 @@ export declare class HelixHeadlessObjectInspector extends HelixElement {
      */
     label: string;
     /**
-     * Whether to leave the copy button off.
+     * Hides the copy button.
      *
      * Negative for the reason Code Block's is: a boolean attribute defaulting to
      * true could never be turned off from markup.
@@ -140,7 +128,7 @@ export declare class HelixHeadlessObjectInspector extends HelixElement {
      */
     noCopy: boolean;
     /**
-     * The value itself, for a page that already holds it.
+     * The value to show, when your code already holds it as an object.
      *
      * Takes precedence over `for`. Anything JSON can say is drawn; anything else
      * is shown as its string.