@fusion.dev/helix-headless 0.152.0 → 0.153.0

package/types/jsx.d.ts

@@ -1128,6 +1128,25 @@ them, and the tooltip and the table hold every reading. */
 Absent draws none: bands read as a composition need no numbers beside
 them, and the tooltip and the table hold every reading. */
   valueAxis?: (HelixHeadlessAreaChart["valueAxis"]) | undefined;
+  /** The words shown in place of the drawing when the table has no readings,
+and the fallback of the `empty` slot. */
+  "empty-text"?: (HelixHeadlessAreaChart["emptyText"]) | undefined;
+  /** The words shown in place of the drawing when the table has no readings,
+and the fallback of the `empty` slot. */
+  emptyText?: (HelixHeadlessAreaChart["emptyText"]) | undefined;
+  /** Whether the readings are still on their way. The chart shows
+`loading-text` in place of an empty drawing until it has readings.
+
+Reflected, so a stylesheet can treat the chart while it waits. A chart
+that already has readings keeps drawing them, so a refresh does not
+blank it. */
+  loading?: (HelixHeadlessAreaChart["loading"]) | undefined;
+  /** The words shown in place of the drawing while `loading` is set and
+there are no readings yet, and the fallback of the `loading` slot. */
+  "loading-text"?: (HelixHeadlessAreaChart["loadingText"]) | undefined;
+  /** The words shown in place of the drawing while `loading` is set and
+there are no readings yet, and the fallback of the `loading` slot. */
+  loadingText?: (HelixHeadlessAreaChart["loadingText"]) | undefined;
   /** The id of the table to read.
 
 Names a table in the same tree, so a chart inside another component's
@@ -1164,6 +1183,29 @@ Set it to the words of the page's language, such as `{position} von
 {count}`, or to nothing to say no position. A slice or a series a
 legend hid is not counted. */
   positionLabel?: (HelixHeadlessAreaChart["positionLabel"]) | undefined;
+  /** The readings as data, in the shape of a table, where the page has no
+table to point `for` at. `for` wins where both are set.
+
+```js
+chart.data = {
+  caption: 'Sessions by channel',
+  columns: ['Month', 'Direct', 'Referral'],
+  rows: [['Jan', 10, 4], ['Feb', 20, 8]],
+}
+```
+
+The first column holds each row's label and every column after it a
+series, as in a table. A cell is a number, words, `null` for a blank,
+or `{ value, text }` for a number shown as words, such as `$128k`. A
+number is shown in `locale`.
+
+**A table is still the better source where the page can show one**:
+it reads with no script and before hydration, and a reader can sort and
+copy it. Data is drawn on the client only, so a server serves the
+frame, and the summary, the keys and the readout are then the whole of
+what a screen reader is given. Set a new object to redraw: the chart
+does not look inside the one it has. */
+  data?: (HelixHeadlessAreaChart["data"]) | undefined;
 
   /** The reading shown moved, or was put away: `index` is the row, or `-1` for none, with its `label`, the `series` the keys rest on, and the `pointerType` that moved it. */
   "onhelix-reading-change"?: ((
@@ -1237,6 +1279,25 @@ them, and the tooltip and the table hold every reading. */
 Absent draws none: bands read as a composition need no numbers beside
 them, and the tooltip and the table hold every reading. */
   "prop:valueAxis"?: (HelixHeadlessAreaChart["valueAxis"]) | undefined;
+  /** The words shown in place of the drawing when the table has no readings,
+and the fallback of the `empty` slot. */
+  "attr:empty-text"?: (HelixHeadlessAreaChart["emptyText"]) | undefined;
+  /** The words shown in place of the drawing when the table has no readings,
+and the fallback of the `empty` slot. */
+  "prop:emptyText"?: (HelixHeadlessAreaChart["emptyText"]) | undefined;
+  /** Whether the readings are still on their way. The chart shows
+`loading-text` in place of an empty drawing until it has readings.
+
+Reflected, so a stylesheet can treat the chart while it waits. A chart
+that already has readings keeps drawing them, so a refresh does not
+blank it. */
+  "prop:loading"?: (HelixHeadlessAreaChart["loading"]) | undefined;
+  /** The words shown in place of the drawing while `loading` is set and
+there are no readings yet, and the fallback of the `loading` slot. */
+  "attr:loading-text"?: (HelixHeadlessAreaChart["loadingText"]) | undefined;
+  /** The words shown in place of the drawing while `loading` is set and
+there are no readings yet, and the fallback of the `loading` slot. */
+  "prop:loadingText"?: (HelixHeadlessAreaChart["loadingText"]) | undefined;
   /** The id of the table to read.
 
 Names a table in the same tree, so a chart inside another component's
@@ -1273,6 +1334,29 @@ Set it to the words of the page's language, such as `{position} von
 {count}`, or to nothing to say no position. A slice or a series a
 legend hid is not counted. */
   "prop:positionLabel"?: (HelixHeadlessAreaChart["positionLabel"]) | undefined;
+  /** The readings as data, in the shape of a table, where the page has no
+table to point `for` at. `for` wins where both are set.
+
+```js
+chart.data = {
+  caption: 'Sessions by channel',
+  columns: ['Month', 'Direct', 'Referral'],
+  rows: [['Jan', 10, 4], ['Feb', 20, 8]],
+}
+```
+
+The first column holds each row's label and every column after it a
+series, as in a table. A cell is a number, words, `null` for a blank,
+or `{ value, text }` for a number shown as words, such as `$128k`. A
+number is shown in `locale`.
+
+**A table is still the better source where the page can show one**:
+it reads with no script and before hydration, and a reader can sort and
+copy it. Data is drawn on the client only, so a server serves the
+frame, and the summary, the keys and the readout are then the whole of
+what a screen reader is given. Set a new object to redraw: the chart
+does not look inside the one it has. */
+  "prop:data"?: (HelixHeadlessAreaChart["data"]) | undefined;
   /** The reading shown moved, or was put away: `index` is the row, or `-1` for none, with its `label`, the `series` the keys rest on, and the `pointerType` that moved it. */
   "on:helix-reading-change"?: ((
     e: HelixHeadlessAreaChartHelixReadingChangeElementEvent,
@@ -1734,6 +1818,25 @@ bottom of bars under `orientation="horizontal"`.
 Absent draws none with one scale, since bars compared with each other need
 no numbers. With `secondary` both scales are drawn whatever this says. */
   valueAxis?: (HelixHeadlessBarChart["valueAxis"]) | undefined;
+  /** The words shown in place of the drawing when the table has no readings,
+and the fallback of the `empty` slot. */
+  "empty-text"?: (HelixHeadlessBarChart["emptyText"]) | undefined;
+  /** The words shown in place of the drawing when the table has no readings,
+and the fallback of the `empty` slot. */
+  emptyText?: (HelixHeadlessBarChart["emptyText"]) | undefined;
+  /** Whether the readings are still on their way. The chart shows
+`loading-text` in place of an empty drawing until it has readings.
+
+Reflected, so a stylesheet can treat the chart while it waits. A chart
+that already has readings keeps drawing them, so a refresh does not
+blank it. */
+  loading?: (HelixHeadlessBarChart["loading"]) | undefined;
+  /** The words shown in place of the drawing while `loading` is set and
+there are no readings yet, and the fallback of the `loading` slot. */
+  "loading-text"?: (HelixHeadlessBarChart["loadingText"]) | undefined;
+  /** The words shown in place of the drawing while `loading` is set and
+there are no readings yet, and the fallback of the `loading` slot. */
+  loadingText?: (HelixHeadlessBarChart["loadingText"]) | undefined;
   /** The id of the table to read.
 
 Names a table in the same tree, so a chart inside another component's
@@ -1770,6 +1873,29 @@ Set it to the words of the page's language, such as `{position} von
 {count}`, or to nothing to say no position. A slice or a series a
 legend hid is not counted. */
   positionLabel?: (HelixHeadlessBarChart["positionLabel"]) | undefined;
+  /** The readings as data, in the shape of a table, where the page has no
+table to point `for` at. `for` wins where both are set.
+
+```js
+chart.data = {
+  caption: 'Sessions by channel',
+  columns: ['Month', 'Direct', 'Referral'],
+  rows: [['Jan', 10, 4], ['Feb', 20, 8]],
+}
+```
+
+The first column holds each row's label and every column after it a
+series, as in a table. A cell is a number, words, `null` for a blank,
+or `{ value, text }` for a number shown as words, such as `$128k`. A
+number is shown in `locale`.
+
+**A table is still the better source where the page can show one**:
+it reads with no script and before hydration, and a reader can sort and
+copy it. Data is drawn on the client only, so a server serves the
+frame, and the summary, the keys and the readout are then the whole of
+what a screen reader is given. Set a new object to redraw: the chart
+does not look inside the one it has. */
+  data?: (HelixHeadlessBarChart["data"]) | undefined;
 
   /** The reading shown moved, or was put away: `index` is the row, or `-1` for none, with its `label`, the `series` the keys rest on, and the `pointerType` that moved it. */
   "onhelix-reading-change"?: ((
@@ -1905,6 +2031,25 @@ bottom of bars under `orientation="horizontal"`.
 Absent draws none with one scale, since bars compared with each other need
 no numbers. With `secondary` both scales are drawn whatever this says. */
   "prop:valueAxis"?: (HelixHeadlessBarChart["valueAxis"]) | undefined;
+  /** The words shown in place of the drawing when the table has no readings,
+and the fallback of the `empty` slot. */
+  "attr:empty-text"?: (HelixHeadlessBarChart["emptyText"]) | undefined;
+  /** The words shown in place of the drawing when the table has no readings,
+and the fallback of the `empty` slot. */
+  "prop:emptyText"?: (HelixHeadlessBarChart["emptyText"]) | undefined;
+  /** Whether the readings are still on their way. The chart shows
+`loading-text` in place of an empty drawing until it has readings.
+
+Reflected, so a stylesheet can treat the chart while it waits. A chart
+that already has readings keeps drawing them, so a refresh does not
+blank it. */
+  "prop:loading"?: (HelixHeadlessBarChart["loading"]) | undefined;
+  /** The words shown in place of the drawing while `loading` is set and
+there are no readings yet, and the fallback of the `loading` slot. */
+  "attr:loading-text"?: (HelixHeadlessBarChart["loadingText"]) | undefined;
+  /** The words shown in place of the drawing while `loading` is set and
+there are no readings yet, and the fallback of the `loading` slot. */
+  "prop:loadingText"?: (HelixHeadlessBarChart["loadingText"]) | undefined;
   /** The id of the table to read.
 
 Names a table in the same tree, so a chart inside another component's
@@ -1941,6 +2086,29 @@ Set it to the words of the page's language, such as `{position} von
 {count}`, or to nothing to say no position. A slice or a series a
 legend hid is not counted. */
   "prop:positionLabel"?: (HelixHeadlessBarChart["positionLabel"]) | undefined;
+  /** The readings as data, in the shape of a table, where the page has no
+table to point `for` at. `for` wins where both are set.
+
+```js
+chart.data = {
+  caption: 'Sessions by channel',
+  columns: ['Month', 'Direct', 'Referral'],
+  rows: [['Jan', 10, 4], ['Feb', 20, 8]],
+}
+```
+
+The first column holds each row's label and every column after it a
+series, as in a table. A cell is a number, words, `null` for a blank,
+or `{ value, text }` for a number shown as words, such as `$128k`. A
+number is shown in `locale`.
+
+**A table is still the better source where the page can show one**:
+it reads with no script and before hydration, and a reader can sort and
+copy it. Data is drawn on the client only, so a server serves the
+frame, and the summary, the keys and the readout are then the whole of
+what a screen reader is given. Set a new object to redraw: the chart
+does not look inside the one it has. */
+  "prop:data"?: (HelixHeadlessBarChart["data"]) | undefined;
   /** The reading shown moved, or was put away: `index` is the row, or `-1` for none, with its `label`, the `series` the keys rest on, and the `pointerType` that moved it. */
   "on:helix-reading-change"?: ((
     e: HelixHeadlessBarChartHelixReadingChangeElementEvent,
@@ -11147,6 +11315,29 @@ Set it to the words of the page's language, such as `{position} von
 {count}`, or to nothing to say no position. A slice or a series a
 legend hid is not counted. */
   positionLabel?: (HelixHeadlessDonutChart["positionLabel"]) | undefined;
+  /** The readings as data, in the shape of a table, where the page has no
+table to point `for` at. `for` wins where both are set.
+
+```js
+chart.data = {
+  caption: 'Sessions by channel',
+  columns: ['Month', 'Direct', 'Referral'],
+  rows: [['Jan', 10, 4], ['Feb', 20, 8]],
+}
+```
+
+The first column holds each row's label and every column after it a
+series, as in a table. A cell is a number, words, `null` for a blank,
+or `{ value, text }` for a number shown as words, such as `$128k`. A
+number is shown in `locale`.
+
+**A table is still the better source where the page can show one**:
+it reads with no script and before hydration, and a reader can sort and
+copy it. Data is drawn on the client only, so a server serves the
+frame, and the summary, the keys and the readout are then the whole of
+what a screen reader is given. Set a new object to redraw: the chart
+does not look inside the one it has. */
+  data?: (HelixHeadlessDonutChart["data"]) | undefined;
 };
 
 export type HelixHeadlessDonutChartSolidJsProps = {
@@ -11250,6 +11441,29 @@ Set it to the words of the page's language, such as `{position} von
 {count}`, or to nothing to say no position. A slice or a series a
 legend hid is not counted. */
   "prop:positionLabel"?: (HelixHeadlessDonutChart["positionLabel"]) | undefined;
+  /** The readings as data, in the shape of a table, where the page has no
+table to point `for` at. `for` wins where both are set.
+
+```js
+chart.data = {
+  caption: 'Sessions by channel',
+  columns: ['Month', 'Direct', 'Referral'],
+  rows: [['Jan', 10, 4], ['Feb', 20, 8]],
+}
+```
+
+The first column holds each row's label and every column after it a
+series, as in a table. A cell is a number, words, `null` for a blank,
+or `{ value, text }` for a number shown as words, such as `$128k`. A
+number is shown in `locale`.
+
+**A table is still the better source where the page can show one**:
+it reads with no script and before hydration, and a reader can sort and
+copy it. Data is drawn on the client only, so a server serves the
+frame, and the summary, the keys and the readout are then the whole of
+what a screen reader is given. Set a new object to redraw: the chart
+does not look inside the one it has. */
+  "prop:data"?: (HelixHeadlessDonutChart["data"]) | undefined;
 
   /** Set the innerHTML of the element */
   innerHTML?: (string) | undefined;
@@ -13888,6 +14102,29 @@ Set it to the words of the page's language, such as `{position} von
 {count}`, or to nothing to say no position. A slice or a series a
 legend hid is not counted. */
   positionLabel?: (HelixHeadlessHeatmap["positionLabel"]) | undefined;
+  /** The readings as data, in the shape of a table, where the page has no
+table to point `for` at. `for` wins where both are set.
+
+```js
+chart.data = {
+  caption: 'Sessions by channel',
+  columns: ['Month', 'Direct', 'Referral'],
+  rows: [['Jan', 10, 4], ['Feb', 20, 8]],
+}
+```
+
+The first column holds each row's label and every column after it a
+series, as in a table. A cell is a number, words, `null` for a blank,
+or `{ value, text }` for a number shown as words, such as `$128k`. A
+number is shown in `locale`.
+
+**A table is still the better source where the page can show one**:
+it reads with no script and before hydration, and a reader can sort and
+copy it. Data is drawn on the client only, so a server serves the
+frame, and the summary, the keys and the readout are then the whole of
+what a screen reader is given. Set a new object to redraw: the chart
+does not look inside the one it has. */
+  data?: (HelixHeadlessHeatmap["data"]) | undefined;
 
   /** Fired once a press or a key has changed which cells are selected. */
   onchange?: ((e: HelixHeadlessHeatmapElementEvent) => void) | undefined;
@@ -14071,6 +14308,29 @@ Set it to the words of the page's language, such as `{position} von
 {count}`, or to nothing to say no position. A slice or a series a
 legend hid is not counted. */
   "prop:positionLabel"?: (HelixHeadlessHeatmap["positionLabel"]) | undefined;
+  /** The readings as data, in the shape of a table, where the page has no
+table to point `for` at. `for` wins where both are set.
+
+```js
+chart.data = {
+  caption: 'Sessions by channel',
+  columns: ['Month', 'Direct', 'Referral'],
+  rows: [['Jan', 10, 4], ['Feb', 20, 8]],
+}
+```
+
+The first column holds each row's label and every column after it a
+series, as in a table. A cell is a number, words, `null` for a blank,
+or `{ value, text }` for a number shown as words, such as `$128k`. A
+number is shown in `locale`.
+
+**A table is still the better source where the page can show one**:
+it reads with no script and before hydration, and a reader can sort and
+copy it. Data is drawn on the client only, so a server serves the
+frame, and the summary, the keys and the readout are then the whole of
+what a screen reader is given. Set a new object to redraw: the chart
+does not look inside the one it has. */
+  "prop:data"?: (HelixHeadlessHeatmap["data"]) | undefined;
   /** Fired once a press or a key has changed which cells are selected. */
   "on:change"?: ((e: HelixHeadlessHeatmapElementEvent) => void) | undefined;
   /** Fired before a press or a key changes which cells are selected, with the `value` it would leave. Cancelable. */
@@ -16031,6 +16291,25 @@ Set it where the distance from nothing is the point rather than the shape,
 and accept that a series which never approaches zero becomes a flat rule
 near the top of the box. */
   zero?: (HelixHeadlessLineChart["zero"]) | undefined;
+  /** The words shown in place of the drawing when the table has no readings,
+and the fallback of the `empty` slot. */
+  "empty-text"?: (HelixHeadlessLineChart["emptyText"]) | undefined;
+  /** The words shown in place of the drawing when the table has no readings,
+and the fallback of the `empty` slot. */
+  emptyText?: (HelixHeadlessLineChart["emptyText"]) | undefined;
+  /** Whether the readings are still on their way. The chart shows
+`loading-text` in place of an empty drawing until it has readings.
+
+Reflected, so a stylesheet can treat the chart while it waits. A chart
+that already has readings keeps drawing them, so a refresh does not
+blank it. */
+  loading?: (HelixHeadlessLineChart["loading"]) | undefined;
+  /** The words shown in place of the drawing while `loading` is set and
+there are no readings yet, and the fallback of the `loading` slot. */
+  "loading-text"?: (HelixHeadlessLineChart["loadingText"]) | undefined;
+  /** The words shown in place of the drawing while `loading` is set and
+there are no readings yet, and the fallback of the `loading` slot. */
+  loadingText?: (HelixHeadlessLineChart["loadingText"]) | undefined;
   /** The id of the table to read.
 
 Names a table in the same tree, so a chart inside another component's
@@ -16067,6 +16346,29 @@ Set it to the words of the page's language, such as `{position} von
 {count}`, or to nothing to say no position. A slice or a series a
 legend hid is not counted. */
   positionLabel?: (HelixHeadlessLineChart["positionLabel"]) | undefined;
+  /** The readings as data, in the shape of a table, where the page has no
+table to point `for` at. `for` wins where both are set.
+
+```js
+chart.data = {
+  caption: 'Sessions by channel',
+  columns: ['Month', 'Direct', 'Referral'],
+  rows: [['Jan', 10, 4], ['Feb', 20, 8]],
+}
+```
+
+The first column holds each row's label and every column after it a
+series, as in a table. A cell is a number, words, `null` for a blank,
+or `{ value, text }` for a number shown as words, such as `$128k`. A
+number is shown in `locale`.
+
+**A table is still the better source where the page can show one**:
+it reads with no script and before hydration, and a reader can sort and
+copy it. Data is drawn on the client only, so a server serves the
+frame, and the summary, the keys and the readout are then the whole of
+what a screen reader is given. Set a new object to redraw: the chart
+does not look inside the one it has. */
+  data?: (HelixHeadlessLineChart["data"]) | undefined;
 
   /** The reading shown moved, or was put away: `index` is the row, or `-1` for none, with its `label`, the `series` the keys rest on, and the `pointerType` that moved it. */
   "onhelix-reading-change"?: ((
@@ -16200,6 +16502,25 @@ Set it where the distance from nothing is the point rather than the shape,
 and accept that a series which never approaches zero becomes a flat rule
 near the top of the box. */
   "prop:zero"?: (HelixHeadlessLineChart["zero"]) | undefined;
+  /** The words shown in place of the drawing when the table has no readings,
+and the fallback of the `empty` slot. */
+  "attr:empty-text"?: (HelixHeadlessLineChart["emptyText"]) | undefined;
+  /** The words shown in place of the drawing when the table has no readings,
+and the fallback of the `empty` slot. */
+  "prop:emptyText"?: (HelixHeadlessLineChart["emptyText"]) | undefined;
+  /** Whether the readings are still on their way. The chart shows
+`loading-text` in place of an empty drawing until it has readings.
+
+Reflected, so a stylesheet can treat the chart while it waits. A chart
+that already has readings keeps drawing them, so a refresh does not
+blank it. */
+  "prop:loading"?: (HelixHeadlessLineChart["loading"]) | undefined;
+  /** The words shown in place of the drawing while `loading` is set and
+there are no readings yet, and the fallback of the `loading` slot. */
+  "attr:loading-text"?: (HelixHeadlessLineChart["loadingText"]) | undefined;
+  /** The words shown in place of the drawing while `loading` is set and
+there are no readings yet, and the fallback of the `loading` slot. */
+  "prop:loadingText"?: (HelixHeadlessLineChart["loadingText"]) | undefined;
   /** The id of the table to read.
 
 Names a table in the same tree, so a chart inside another component's
@@ -16236,6 +16557,29 @@ Set it to the words of the page's language, such as `{position} von
 {count}`, or to nothing to say no position. A slice or a series a
 legend hid is not counted. */
   "prop:positionLabel"?: (HelixHeadlessLineChart["positionLabel"]) | undefined;
+  /** The readings as data, in the shape of a table, where the page has no
+table to point `for` at. `for` wins where both are set.
+
+```js
+chart.data = {
+  caption: 'Sessions by channel',
+  columns: ['Month', 'Direct', 'Referral'],
+  rows: [['Jan', 10, 4], ['Feb', 20, 8]],
+}
+```
+
+The first column holds each row's label and every column after it a
+series, as in a table. A cell is a number, words, `null` for a blank,
+or `{ value, text }` for a number shown as words, such as `$128k`. A
+number is shown in `locale`.
+
+**A table is still the better source where the page can show one**:
+it reads with no script and before hydration, and a reader can sort and
+copy it. Data is drawn on the client only, so a server serves the
+frame, and the summary, the keys and the readout are then the whole of
+what a screen reader is given. Set a new object to redraw: the chart
+does not look inside the one it has. */
+  "prop:data"?: (HelixHeadlessLineChart["data"]) | undefined;
   /** The reading shown moved, or was put away: `index` is the row, or `-1` for none, with its `label`, the `series` the keys rest on, and the `pointerType` that moved it. */
   "on:helix-reading-change"?: ((
     e: HelixHeadlessLineChartHelixReadingChangeElementEvent,
@@ -22352,7 +22696,8 @@ decimals. Written as JSON in the attribute.
 
 A `percent` style writes the share of the range, and any other the value
 itself, so the example says "18 GB". Absent is a whole percentage. The
-words are announced as well as shown. `value-text` still wins. */
+words are announced whether or not `show-value` shows them. `value-text`
+still wins. */
   "format-options"?: (HelixHeadlessProgress["formatOptions"]) | undefined;
   /** `Intl.NumberFormat` options the reading is written with, as React Aria's
 Meter and ProgressBar take them: a unit, a currency, or a number of
@@ -22364,7 +22709,8 @@ decimals. Written as JSON in the attribute.
 
 A `percent` style writes the share of the range, and any other the value
 itself, so the example says "18 GB". Absent is a whole percentage. The
-words are announced as well as shown. `value-text` still wins. */
+words are announced whether or not `show-value` shows them. `value-text`
+still wins. */
   formatOptions?: (HelixHeadlessProgress["formatOptions"]) | undefined;
   /** Whether the length of the task is unknown. The bar then shows activity
 without a value.
@@ -22480,7 +22826,8 @@ decimals. Written as JSON in the attribute.
 
 A `percent` style writes the share of the range, and any other the value
 itself, so the example says "18 GB". Absent is a whole percentage. The
-words are announced as well as shown. `value-text` still wins. */
+words are announced whether or not `show-value` shows them. `value-text`
+still wins. */
   "attr:format-options"?: (HelixHeadlessProgress["formatOptions"]) | undefined;
   /** `Intl.NumberFormat` options the reading is written with, as React Aria's
 Meter and ProgressBar take them: a unit, a currency, or a number of
@@ -22492,7 +22839,8 @@ decimals. Written as JSON in the attribute.
 
 A `percent` style writes the share of the range, and any other the value
 itself, so the example says "18 GB". Absent is a whole percentage. The
-words are announced as well as shown. `value-text` still wins. */
+words are announced whether or not `show-value` shows them. `value-text`
+still wins. */
   "prop:formatOptions"?: (HelixHeadlessProgress["formatOptions"]) | undefined;
   /** Whether the length of the task is unknown. The bar then shows activity
 without a value.
@@ -23576,6 +23924,25 @@ Absent draws none. A series with fewer than two points, or with every
 point at one measure across, has no line to draw. The summary already
 gives each series' correlation, which says how near the points are to it. */
   trend?: (HelixHeadlessScatterChart["trend"]) | undefined;
+  /** The words shown in place of the drawing when the table has no readings,
+and the fallback of the `empty` slot. */
+  "empty-text"?: (HelixHeadlessScatterChart["emptyText"]) | undefined;
+  /** The words shown in place of the drawing when the table has no readings,
+and the fallback of the `empty` slot. */
+  emptyText?: (HelixHeadlessScatterChart["emptyText"]) | undefined;
+  /** Whether the readings are still on their way. The chart shows
+`loading-text` in place of an empty drawing until it has readings.
+
+Reflected, so a stylesheet can treat the chart while it waits. A chart
+that already has readings keeps drawing them, so a refresh does not
+blank it. */
+  loading?: (HelixHeadlessScatterChart["loading"]) | undefined;
+  /** The words shown in place of the drawing while `loading` is set and
+there are no readings yet, and the fallback of the `loading` slot. */
+  "loading-text"?: (HelixHeadlessScatterChart["loadingText"]) | undefined;
+  /** The words shown in place of the drawing while `loading` is set and
+there are no readings yet, and the fallback of the `loading` slot. */
+  loadingText?: (HelixHeadlessScatterChart["loadingText"]) | undefined;
   /** The id of the table to read.
 
 Names a table in the same tree, so a chart inside another component's
@@ -23612,6 +23979,29 @@ Set it to the words of the page's language, such as `{position} von
 {count}`, or to nothing to say no position. A slice or a series a
 legend hid is not counted. */
   positionLabel?: (HelixHeadlessScatterChart["positionLabel"]) | undefined;
+  /** The readings as data, in the shape of a table, where the page has no
+table to point `for` at. `for` wins where both are set.
+
+```js
+chart.data = {
+  caption: 'Sessions by channel',
+  columns: ['Month', 'Direct', 'Referral'],
+  rows: [['Jan', 10, 4], ['Feb', 20, 8]],
+}
+```
+
+The first column holds each row's label and every column after it a
+series, as in a table. A cell is a number, words, `null` for a blank,
+or `{ value, text }` for a number shown as words, such as `$128k`. A
+number is shown in `locale`.
+
+**A table is still the better source where the page can show one**:
+it reads with no script and before hydration, and a reader can sort and
+copy it. Data is drawn on the client only, so a server serves the
+frame, and the summary, the keys and the readout are then the whole of
+what a screen reader is given. Set a new object to redraw: the chart
+does not look inside the one it has. */
+  data?: (HelixHeadlessScatterChart["data"]) | undefined;
 
   /** The reading shown moved, or was put away: `index` is the row, or `-1` for none, with its `label`, the `series` the keys rest on, and the `pointerType` that moved it. */
   "onhelix-reading-change"?: ((
@@ -23683,6 +24073,25 @@ Absent draws none. A series with fewer than two points, or with every
 point at one measure across, has no line to draw. The summary already
 gives each series' correlation, which says how near the points are to it. */
   "prop:trend"?: (HelixHeadlessScatterChart["trend"]) | undefined;
+  /** The words shown in place of the drawing when the table has no readings,
+and the fallback of the `empty` slot. */
+  "attr:empty-text"?: (HelixHeadlessScatterChart["emptyText"]) | undefined;
+  /** The words shown in place of the drawing when the table has no readings,
+and the fallback of the `empty` slot. */
+  "prop:emptyText"?: (HelixHeadlessScatterChart["emptyText"]) | undefined;
+  /** Whether the readings are still on their way. The chart shows
+`loading-text` in place of an empty drawing until it has readings.
+
+Reflected, so a stylesheet can treat the chart while it waits. A chart
+that already has readings keeps drawing them, so a refresh does not
+blank it. */
+  "prop:loading"?: (HelixHeadlessScatterChart["loading"]) | undefined;
+  /** The words shown in place of the drawing while `loading` is set and
+there are no readings yet, and the fallback of the `loading` slot. */
+  "attr:loading-text"?: (HelixHeadlessScatterChart["loadingText"]) | undefined;
+  /** The words shown in place of the drawing while `loading` is set and
+there are no readings yet, and the fallback of the `loading` slot. */
+  "prop:loadingText"?: (HelixHeadlessScatterChart["loadingText"]) | undefined;
   /** The id of the table to read.
 
 Names a table in the same tree, so a chart inside another component's
@@ -23719,6 +24128,29 @@ Set it to the words of the page's language, such as `{position} von
 {count}`, or to nothing to say no position. A slice or a series a
 legend hid is not counted. */
   "prop:positionLabel"?: (HelixHeadlessScatterChart["positionLabel"]) | undefined;
+  /** The readings as data, in the shape of a table, where the page has no
+table to point `for` at. `for` wins where both are set.
+
+```js
+chart.data = {
+  caption: 'Sessions by channel',
+  columns: ['Month', 'Direct', 'Referral'],
+  rows: [['Jan', 10, 4], ['Feb', 20, 8]],
+}
+```
+
+The first column holds each row's label and every column after it a
+series, as in a table. A cell is a number, words, `null` for a blank,
+or `{ value, text }` for a number shown as words, such as `$128k`. A
+number is shown in `locale`.
+
+**A table is still the better source where the page can show one**:
+it reads with no script and before hydration, and a reader can sort and
+copy it. Data is drawn on the client only, so a server serves the
+frame, and the summary, the keys and the readout are then the whole of
+what a screen reader is given. Set a new object to redraw: the chart
+does not look inside the one it has. */
+  "prop:data"?: (HelixHeadlessScatterChart["data"]) | undefined;
   /** The reading shown moved, or was put away: `index` is the row, or `-1` for none, with its `label`, the `series` the keys rest on, and the `pointerType` that moved it. */
   "on:helix-reading-change"?: ((
     e: HelixHeadlessScatterChartHelixReadingChangeElementEvent,
@@ -33142,6 +33574,16 @@ export type CustomElements = {
    * tap or key, and `helix-reading-press` says a reading was clicked, tapped, or
    * pressed with Enter or Space, for a page that opens what a reading stands for.
    *
+   * **`data` takes the readings as data** where the page has no table to point
+   * `for` at, in a table's shape: the column headings, then one row per reading
+   * with its label first. A table is still the better source where the page can
+   * show one, since it reads before any script runs.
+   *
+   * **A chart with nothing to draw says so.** A table with no readings shows
+   * `empty-text`, "No readings", in the plot, and `loading` shows `loading-text`
+   * there until readings arrive. The `empty` and `loading` slots take markup in
+   * their place, such as a link to add the first reading.
+   *
    * ## Attributes & Properties
    *
    * Component attributes and properties that can be applied to the element or by using JavaScript.
@@ -33188,6 +33630,16 @@ export type CustomElements = {
    *
    * Absent draws none: bands read as a composition need no numbers beside
    * them, and the tooltip and the table hold every reading.
+   * - `empty-text`/`emptyText`: The words shown in place of the drawing when the table has no readings,
+   * and the fallback of the `empty` slot.
+   * - `loading`: Whether the readings are still on their way. The chart shows
+   * `loading-text` in place of an empty drawing until it has readings.
+   *
+   * Reflected, so a stylesheet can treat the chart while it waits. A chart
+   * that already has readings keeps drawing them, so a refresh does not
+   * blank it.
+   * - `loading-text`/`loadingText`: The words shown in place of the drawing while `loading` is set and
+   * there are no readings yet, and the fallback of the `loading` slot.
    * - `for`: The id of the table to read.
    *
    * Names a table in the same tree, so a chart inside another component's
@@ -33218,6 +33670,28 @@ export type CustomElements = {
    * cannot be cast onto across unrelated classes, so it would be invisible to
    * every chart that needs it. Reading where a pointer is resting is a fair
    * thing to ask a chart anyway. (property only) (readonly)
+   * - `data`: The readings as data, in the shape of a table, where the page has no
+   * table to point `for` at. `for` wins where both are set.
+   *
+   * ```js
+   * chart.data = {
+   *   caption: 'Sessions by channel',
+   *   columns: ['Month', 'Direct', 'Referral'],
+   *   rows: [['Jan', 10, 4], ['Feb', 20, 8]],
+   * }
+   * ```
+   *
+   * The first column holds each row's label and every column after it a
+   * series, as in a table. A cell is a number, words, `null` for a blank,
+   * or `{ value, text }` for a number shown as words, such as `$128k`. A
+   * number is shown in `locale`.
+   *
+   * **A table is still the better source where the page can show one**:
+   * it reads with no script and before hydration, and a reader can sort and
+   * copy it. Data is drawn on the client only, so a server serves the
+   * frame, and the summary, the keys and the readout are then the whole of
+   * what a screen reader is given. Set a new object to redraw: the chart
+   * does not look inside the one it has. (property only)
    * - `series`: The table's columns, one series each. Empty when there is no table.
    *
    * Held by the controller between edits, so a render reading this five
@@ -33234,6 +33708,9 @@ export type CustomElements = {
    * names an element, and the chart is a generic around its plot: written
    * on the host, the name reached nobody. The plot takes it, as Heatmap's
    * strip always did. (property only) (readonly)
+   * - `readingsKnown`: Whether the readings have been looked for: false on the server and
+   * while hydrating, where no table is resolved and no data is read. A
+   * chart says it has no readings only once this is true. (property only) (readonly)
    * - `sourceRows`: Every row of the table, with each cell's text and number.
    *
    * This is where a tooltip's content comes from, and it is deliberately not
@@ -33280,6 +33757,13 @@ export type CustomElements = {
    * - `helix-reading-change`: The reading shown moved, or was put away: `index` is the row, or `-1` for none, with its `label`, the `series` the keys rest on, and the `pointerType` that moved it.
    * - `helix-reading-press`: A reading was clicked, tapped, or pressed with Enter or Space, with the same detail as `helix-reading-change`.
    *
+   * ## Slots
+   *
+   * Areas where markup can be added to the component.
+   *
+   * - `empty`: Content shown in place of the drawing when the table has no readings, such as a link to add the first. Falls back to `empty-text`.
+   * - `loading`: Content shown in place of the drawing while `loading` is set and there are no readings yet. Falls back to `loading-text`.
+   *
    * ## Methods
    *
    * Methods that can be called to access component functionality.
@@ -33329,12 +33813,14 @@ export type CustomElements = {
    * - `area`: One part's band.
    * - `axis`: The numbers of the scale beside the plot, under `value-axis`.
    * - `baseline`: The rule at zero, which is the floor of the drawing.
+   * - `empty`: The words in place of the drawing when the table has no readings: the `empty` slot, falling back to `empty-text`. Not drawn while the table cannot be read yet, on the server and during hydration.
    * - `gridline`: One rule across the plot, under `gridlines`.
    * - `guide`: A rule down the reading a pointer is resting on.
    * - `label`: One reading's name.
    * - `labels`: The row of reading names.
    * - `line`: The top edge of one part's band.
    * - `live`: The readout: a polite live region that says the reading the keys moved to. Hide it visually.
+   * - `loading`: The words in place of the drawing while `loading` is set and there are no readings: the `loading` slot, falling back to `loading-text`.
    * - `mark`: The invisible point the tooltip is anchored to.
    * - `plot`: The drawing, which takes focus to be read by key.
    * - `summary`: The total and each part's share at the latest reading, written as a sentence for screen readers.
@@ -33720,6 +34206,16 @@ export type CustomElements = {
    * tap or key, and `helix-reading-press` says a reading was clicked, tapped, or
    * pressed with Enter or Space, for a page that opens what a reading stands for.
    *
+   * **`data` takes the readings as data** where the page has no table to point
+   * `for` at, in a table's shape: the column headings, then one row per reading
+   * with its label first. A table is still the better source where the page can
+   * show one, since it reads before any script runs.
+   *
+   * **A chart with nothing to draw says so.** A table with no readings shows
+   * `empty-text`, "No readings", in the plot, and `loading` shows `loading-text`
+   * there until readings arrive. The `empty` and `loading` slots take markup in
+   * their place, such as a link to add the first reading.
+   *
    * ## Attributes & Properties
    *
    * Component attributes and properties that can be applied to the element or by using JavaScript.
@@ -33825,6 +34321,16 @@ export type CustomElements = {
    *
    * Absent draws none with one scale, since bars compared with each other need
    * no numbers. With `secondary` both scales are drawn whatever this says.
+   * - `empty-text`/`emptyText`: The words shown in place of the drawing when the table has no readings,
+   * and the fallback of the `empty` slot.
+   * - `loading`: Whether the readings are still on their way. The chart shows
+   * `loading-text` in place of an empty drawing until it has readings.
+   *
+   * Reflected, so a stylesheet can treat the chart while it waits. A chart
+   * that already has readings keeps drawing them, so a refresh does not
+   * blank it.
+   * - `loading-text`/`loadingText`: The words shown in place of the drawing while `loading` is set and
+   * there are no readings yet, and the fallback of the `loading` slot.
    * - `for`: The id of the table to read.
    *
    * Names a table in the same tree, so a chart inside another component's
@@ -33855,6 +34361,28 @@ export type CustomElements = {
    * cannot be cast onto across unrelated classes, so it would be invisible to
    * every chart that needs it. Reading where a pointer is resting is a fair
    * thing to ask a chart anyway. (property only) (readonly)
+   * - `data`: The readings as data, in the shape of a table, where the page has no
+   * table to point `for` at. `for` wins where both are set.
+   *
+   * ```js
+   * chart.data = {
+   *   caption: 'Sessions by channel',
+   *   columns: ['Month', 'Direct', 'Referral'],
+   *   rows: [['Jan', 10, 4], ['Feb', 20, 8]],
+   * }
+   * ```
+   *
+   * The first column holds each row's label and every column after it a
+   * series, as in a table. A cell is a number, words, `null` for a blank,
+   * or `{ value, text }` for a number shown as words, such as `$128k`. A
+   * number is shown in `locale`.
+   *
+   * **A table is still the better source where the page can show one**:
+   * it reads with no script and before hydration, and a reader can sort and
+   * copy it. Data is drawn on the client only, so a server serves the
+   * frame, and the summary, the keys and the readout are then the whole of
+   * what a screen reader is given. Set a new object to redraw: the chart
+   * does not look inside the one it has. (property only)
    * - `series`: The table's columns, one series each. Empty when there is no table.
    *
    * Held by the controller between edits, so a render reading this five
@@ -33871,6 +34399,9 @@ export type CustomElements = {
    * names an element, and the chart is a generic around its plot: written
    * on the host, the name reached nobody. The plot takes it, as Heatmap's
    * strip always did. (property only) (readonly)
+   * - `readingsKnown`: Whether the readings have been looked for: false on the server and
+   * while hydrating, where no table is resolved and no data is read. A
+   * chart says it has no readings only once this is true. (property only) (readonly)
    * - `sourceRows`: Every row of the table, with each cell's text and number.
    *
    * This is where a tooltip's content comes from, and it is deliberately not
@@ -33917,6 +34448,13 @@ export type CustomElements = {
    * - `helix-reading-change`: The reading shown moved, or was put away: `index` is the row, or `-1` for none, with its `label`, the `series` the keys rest on, and the `pointerType` that moved it.
    * - `helix-reading-press`: A reading was clicked, tapped, or pressed with Enter or Space, with the same detail as `helix-reading-change`.
    *
+   * ## Slots
+   *
+   * Areas where markup can be added to the component.
+   *
+   * - `empty`: Content shown in place of the drawing when the table has no readings, such as a link to add the first. Falls back to `empty-text`.
+   * - `loading`: Content shown in place of the drawing while `loading` is set and there are no readings yet. Falls back to `loading-text`.
+   *
    * ## Methods
    *
    * Methods that can be called to access component functionality.
@@ -33971,6 +34509,7 @@ export type CustomElements = {
    * - `bar-wash-end`: The far stop of a bar's gradient, where one is used.
    * - `bar-wash-start`: The stop of a bar's gradient at its base.
    * - `baseline`: The line the columns stand on.
+   * - `empty`: The words in place of the drawing when the table has no readings: the `empty` slot, falling back to `empty-text`. Not drawn while the table cannot be read yet, on the server and during hydration.
    * - `gridline`: One gridline across the plot, drawn when `gridlines` is set.
    * - `group`: One category's columns, together.
    * - `group-active`: The group the tooltip describes. Set together with `group`.
@@ -33978,6 +34517,7 @@ export type CustomElements = {
    * - `labels`: The row of category names.
    * - `line`: A series drawn as a line, named in `lines`.
    * - `live`: The readout: a polite live region that says the reading the keys moved to. Hide it visually.
+   * - `loading`: The words in place of the drawing while `loading` is set and there are no readings: the `loading` slot, falling back to `loading-text`.
    * - `mark`: The invisible point the tooltip is anchored to.
    * - `plot`: The drawing, which takes focus to be read by key.
    * - `summary`: The chart's name and each series' highest reading, written as a sentence for screen readers. Hide it visually.
@@ -40516,6 +41056,28 @@ export type CustomElements = {
    * cannot be cast onto across unrelated classes, so it would be invisible to
    * every chart that needs it. Reading where a pointer is resting is a fair
    * thing to ask a chart anyway. (property only) (readonly)
+   * - `data`: The readings as data, in the shape of a table, where the page has no
+   * table to point `for` at. `for` wins where both are set.
+   *
+   * ```js
+   * chart.data = {
+   *   caption: 'Sessions by channel',
+   *   columns: ['Month', 'Direct', 'Referral'],
+   *   rows: [['Jan', 10, 4], ['Feb', 20, 8]],
+   * }
+   * ```
+   *
+   * The first column holds each row's label and every column after it a
+   * series, as in a table. A cell is a number, words, `null` for a blank,
+   * or `{ value, text }` for a number shown as words, such as `$128k`. A
+   * number is shown in `locale`.
+   *
+   * **A table is still the better source where the page can show one**:
+   * it reads with no script and before hydration, and a reader can sort and
+   * copy it. Data is drawn on the client only, so a server serves the
+   * frame, and the summary, the keys and the readout are then the whole of
+   * what a screen reader is given. Set a new object to redraw: the chart
+   * does not look inside the one it has. (property only)
    * - `series`: The table's columns, one series each. Empty when there is no table.
    *
    * Held by the controller between edits, so a render reading this five
@@ -40532,6 +41094,9 @@ export type CustomElements = {
    * names an element, and the chart is a generic around its plot: written
    * on the host, the name reached nobody. The plot takes it, as Heatmap's
    * strip always did. (property only) (readonly)
+   * - `readingsKnown`: Whether the readings have been looked for: false on the server and
+   * while hydrating, where no table is resolved and no data is read. A
+   * chart says it has no readings only once this is true. (property only) (readonly)
    * - `sourceRows`: Every row of the table, with each cell's text and number.
    *
    * This is where a tooltip's content comes from, and it is deliberately not
@@ -43055,6 +43620,28 @@ export type CustomElements = {
    * cannot be cast onto across unrelated classes, so it would be invisible to
    * every chart that needs it. Reading where a pointer is resting is a fair
    * thing to ask a chart anyway. (property only) (readonly)
+   * - `data`: The readings as data, in the shape of a table, where the page has no
+   * table to point `for` at. `for` wins where both are set.
+   *
+   * ```js
+   * chart.data = {
+   *   caption: 'Sessions by channel',
+   *   columns: ['Month', 'Direct', 'Referral'],
+   *   rows: [['Jan', 10, 4], ['Feb', 20, 8]],
+   * }
+   * ```
+   *
+   * The first column holds each row's label and every column after it a
+   * series, as in a table. A cell is a number, words, `null` for a blank,
+   * or `{ value, text }` for a number shown as words, such as `$128k`. A
+   * number is shown in `locale`.
+   *
+   * **A table is still the better source where the page can show one**:
+   * it reads with no script and before hydration, and a reader can sort and
+   * copy it. Data is drawn on the client only, so a server serves the
+   * frame, and the summary, the keys and the readout are then the whole of
+   * what a screen reader is given. Set a new object to redraw: the chart
+   * does not look inside the one it has. (property only)
    * - `series`: The table's columns, one series each. Empty when there is no table.
    *
    * Held by the controller between edits, so a render reading this five
@@ -43071,6 +43658,9 @@ export type CustomElements = {
    * names an element, and the chart is a generic around its plot: written
    * on the host, the name reached nobody. The plot takes it, as Heatmap's
    * strip always did. (property only) (readonly)
+   * - `readingsKnown`: Whether the readings have been looked for: false on the server and
+   * while hydrating, where no table is resolved and no data is read. A
+   * chart says it has no readings only once this is true. (property only) (readonly)
    * - `sourceRows`: Every row of the table, with each cell's text and number.
    *
    * This is where a tooltip's content comes from, and it is deliberately not
@@ -44709,6 +45299,16 @@ export type CustomElements = {
    * tap or key, and `helix-reading-press` says a reading was clicked, tapped, or
    * pressed with Enter or Space, for a page that opens what a reading stands for.
    *
+   * **`data` takes the readings as data** where the page has no table to point
+   * `for` at, in a table's shape: the column headings, then one row per reading
+   * with its label first. A table is still the better source where the page can
+   * show one, since it reads before any script runs.
+   *
+   * **A chart with nothing to draw says so.** A table with no readings shows
+   * `empty-text`, "No readings", in the plot, and `loading` shows `loading-text`
+   * there until readings arrive. The `empty` and `loading` slots take markup in
+   * their place, such as a link to add the first reading.
+   *
    * ## Attributes & Properties
    *
    * Component attributes and properties that can be applied to the element or by using JavaScript.
@@ -44819,6 +45419,16 @@ export type CustomElements = {
    * Set it where the distance from nothing is the point rather than the shape,
    * and accept that a series which never approaches zero becomes a flat rule
    * near the top of the box.
+   * - `empty-text`/`emptyText`: The words shown in place of the drawing when the table has no readings,
+   * and the fallback of the `empty` slot.
+   * - `loading`: Whether the readings are still on their way. The chart shows
+   * `loading-text` in place of an empty drawing until it has readings.
+   *
+   * Reflected, so a stylesheet can treat the chart while it waits. A chart
+   * that already has readings keeps drawing them, so a refresh does not
+   * blank it.
+   * - `loading-text`/`loadingText`: The words shown in place of the drawing while `loading` is set and
+   * there are no readings yet, and the fallback of the `loading` slot.
    * - `for`: The id of the table to read.
    *
    * Names a table in the same tree, so a chart inside another component's
@@ -44849,6 +45459,28 @@ export type CustomElements = {
    * cannot be cast onto across unrelated classes, so it would be invisible to
    * every chart that needs it. Reading where a pointer is resting is a fair
    * thing to ask a chart anyway. (property only) (readonly)
+   * - `data`: The readings as data, in the shape of a table, where the page has no
+   * table to point `for` at. `for` wins where both are set.
+   *
+   * ```js
+   * chart.data = {
+   *   caption: 'Sessions by channel',
+   *   columns: ['Month', 'Direct', 'Referral'],
+   *   rows: [['Jan', 10, 4], ['Feb', 20, 8]],
+   * }
+   * ```
+   *
+   * The first column holds each row's label and every column after it a
+   * series, as in a table. A cell is a number, words, `null` for a blank,
+   * or `{ value, text }` for a number shown as words, such as `$128k`. A
+   * number is shown in `locale`.
+   *
+   * **A table is still the better source where the page can show one**:
+   * it reads with no script and before hydration, and a reader can sort and
+   * copy it. Data is drawn on the client only, so a server serves the
+   * frame, and the summary, the keys and the readout are then the whole of
+   * what a screen reader is given. Set a new object to redraw: the chart
+   * does not look inside the one it has. (property only)
    * - `series`: The table's columns, one series each. Empty when there is no table.
    *
    * Held by the controller between edits, so a render reading this five
@@ -44865,6 +45497,9 @@ export type CustomElements = {
    * names an element, and the chart is a generic around its plot: written
    * on the host, the name reached nobody. The plot takes it, as Heatmap's
    * strip always did. (property only) (readonly)
+   * - `readingsKnown`: Whether the readings have been looked for: false on the server and
+   * while hydrating, where no table is resolved and no data is read. A
+   * chart says it has no readings only once this is true. (property only) (readonly)
    * - `sourceRows`: Every row of the table, with each cell's text and number.
    *
    * This is where a tooltip's content comes from, and it is deliberately not
@@ -44911,6 +45546,13 @@ export type CustomElements = {
    * - `helix-reading-change`: The reading shown moved, or was put away: `index` is the row, or `-1` for none, with its `label`, the `series` the keys rest on, and the `pointerType` that moved it.
    * - `helix-reading-press`: A reading was clicked, tapped, or pressed with Enter or Space, with the same detail as `helix-reading-change`.
    *
+   * ## Slots
+   *
+   * Areas where markup can be added to the component.
+   *
+   * - `empty`: Content shown in place of the drawing when the table has no readings, such as a link to add the first. Falls back to `empty-text`.
+   * - `loading`: Content shown in place of the drawing while `loading` is set and there are no readings yet. Falls back to `loading-text`.
+   *
    * ## Methods
    *
    * Methods that can be called to access component functionality.
@@ -44963,6 +45605,7 @@ export type CustomElements = {
    * - `axis`: The numbers of the scale beside the plot, under `value-axis`.
    * - `band`: The band around the reading under the pointer.
    * - `baseline`: The rule at zero, where zero is inside the range.
+   * - `empty`: The words in place of the drawing when the table has no readings: the `empty` slot, falling back to `empty-text`. Not drawn while the table cannot be read yet, on the server and during hydration.
    * - `gridline`: One rule across the plot, under `gridlines`.
    * - `guide`: A rule down the reading a pointer is resting on.
    * - `label`: One reading's name.
@@ -44970,6 +45613,7 @@ export type CustomElements = {
    * - `line`: The line for one series.
    * - `line-dashed`: A `line` whose series `dashed` names. Set alongside `line`.
    * - `live`: The readout: a polite live region that says the reading the keys moved to. Hide it visually.
+   * - `loading`: The words in place of the drawing while `loading` is set and there are no readings: the `loading` slot, falling back to `loading-text`.
    * - `mark`: The invisible point the tooltip is anchored to.
    * - `marker`: The mark on one reading, under `markers`, and on a reading with a blank on either side. Placed with `inset-inline-start` and `inset-block-start`, and carries its series color as `--chart-series`.
    * - `marker-lone`: A `marker` on a reading with a blank on either side, which no line reaches. Set alongside `marker`.
@@ -45753,6 +46397,11 @@ export type CustomElements = {
    * Draws two concentric circles: a track and a moving arc. The track shows the
    * arc as a proportion of a whole, and costs one element.
    *
+   * **For work whose length is known, use `Progress` with `shape="ring"`.** It
+   * draws the same ring filled to the value, says the value as a progress bar
+   * does, and says when the work is complete. A loader claims no proportion, so
+   * it takes no value.
+   *
    * **The center is a slot, empty by default.** Put your logo there once, where
    * your app wraps the loader. When nothing is slotted, nothing extra is
    * rendered.
@@ -50259,6 +50908,15 @@ export type CustomElements = {
    *
    * The fill is a fraction of the track, written as a custom property.
    *
+   * **The reading is said in the words the bar would show**: a whole percentage
+   * of the range in `locale`, the reading `format-options` writes, or
+   * `value-text`, as `aria-valuetext` beside the number.
+   *
+   * **Words set in the default slot are drawn on the bar**, or in the middle of a
+   * ring, such as `62%` or `3 of 8`, and are what the bar says as its reading
+   * where `value-text` is not set. While there are any, the bar carries
+   * `:state(content)`, so a sheet can make room for them.
+   *
    * **Reaching `max` is said and sent.** When the value arrives at `max` from
    * below, the bar says `complete-label`, "Complete" by default, in a polite
    * `live` region and sends `helix-complete`, so a reader hears that the work is
@@ -50285,7 +50943,8 @@ export type CustomElements = {
    *
    * A `percent` style writes the share of the range, and any other the value
    * itself, so the example says "18 GB". Absent is a whole percentage. The
-   * words are announced as well as shown. `value-text` still wins.
+   * words are announced whether or not `show-value` shows them. `value-text`
+   * still wins.
    * - `indeterminate`: Whether the length of the task is unknown. The bar then shows activity
    * without a value.
    *
@@ -50374,6 +51033,7 @@ export type CustomElements = {
    *
    * Areas where markup can be added to the component.
    *
+   * - `(default)`: Words drawn on the bar, or in the middle of a ring, such as the reading. Said as the reading where `value-text` is not set.
    * - `label`: A visible label. Its words name the progress bar in place of `label`.
    *
    * ## CSS Custom Properties
@@ -50386,6 +51046,7 @@ export type CustomElements = {
    *
    * Custom selectors for styling elements within the component.
    *
+   * - `content`: The box holding the words of the default slot, over the track or in the middle of the ring. Carries `--progress-fraction`.
    * - `groove`: The unfilled circle under the ring's filled arc.
    * - `indicator`: The filled part that shows the work done.
    * - `live`: A polite region that says `complete-label` when the work is done, rendered from that moment. Hide it visually.
@@ -50397,6 +51058,7 @@ export type CustomElements = {
    * These can be used to apply styling when a component is in a given state.
    *
    * - `complete`: The value is at `max` and the bar is not indeterminate.
+   * - `content`: Words are set in the default slot.
    * - `settled`: Set one frame after the first render. Transitions wait for it, so an element does not animate its own arrival.
    */
   "helix-headless-progress": Partial<
@@ -51330,6 +51992,16 @@ export type CustomElements = {
    * tap or key, and `helix-reading-press` says a reading was clicked, tapped, or
    * pressed with Enter or Space, for a page that opens what a reading stands for.
    *
+   * **`data` takes the readings as data** where the page has no table to point
+   * `for` at, in a table's shape: the column headings, then one row per reading
+   * with its label first. A table is still the better source where the page can
+   * show one, since it reads before any script runs.
+   *
+   * **A chart with nothing to draw says so.** A table with no readings shows
+   * `empty-text`, "No readings", in the plot, and `loading` shows `loading-text`
+   * there until readings arrive. The `empty` and `loading` slots take markup in
+   * their place, such as a link to add the first reading.
+   *
    * ## Attributes & Properties
    *
    * Component attributes and properties that can be applied to the element or by using JavaScript.
@@ -51365,6 +52037,16 @@ export type CustomElements = {
    * Absent draws none. A series with fewer than two points, or with every
    * point at one measure across, has no line to draw. The summary already
    * gives each series' correlation, which says how near the points are to it.
+   * - `empty-text`/`emptyText`: The words shown in place of the drawing when the table has no readings,
+   * and the fallback of the `empty` slot.
+   * - `loading`: Whether the readings are still on their way. The chart shows
+   * `loading-text` in place of an empty drawing until it has readings.
+   *
+   * Reflected, so a stylesheet can treat the chart while it waits. A chart
+   * that already has readings keeps drawing them, so a refresh does not
+   * blank it.
+   * - `loading-text`/`loadingText`: The words shown in place of the drawing while `loading` is set and
+   * there are no readings yet, and the fallback of the `loading` slot.
    * - `for`: The id of the table to read.
    *
    * Names a table in the same tree, so a chart inside another component's
@@ -51395,6 +52077,28 @@ export type CustomElements = {
    * cannot be cast onto across unrelated classes, so it would be invisible to
    * every chart that needs it. Reading where a pointer is resting is a fair
    * thing to ask a chart anyway. (property only) (readonly)
+   * - `data`: The readings as data, in the shape of a table, where the page has no
+   * table to point `for` at. `for` wins where both are set.
+   *
+   * ```js
+   * chart.data = {
+   *   caption: 'Sessions by channel',
+   *   columns: ['Month', 'Direct', 'Referral'],
+   *   rows: [['Jan', 10, 4], ['Feb', 20, 8]],
+   * }
+   * ```
+   *
+   * The first column holds each row's label and every column after it a
+   * series, as in a table. A cell is a number, words, `null` for a blank,
+   * or `{ value, text }` for a number shown as words, such as `$128k`. A
+   * number is shown in `locale`.
+   *
+   * **A table is still the better source where the page can show one**:
+   * it reads with no script and before hydration, and a reader can sort and
+   * copy it. Data is drawn on the client only, so a server serves the
+   * frame, and the summary, the keys and the readout are then the whole of
+   * what a screen reader is given. Set a new object to redraw: the chart
+   * does not look inside the one it has. (property only)
    * - `series`: The table's columns, one series each. Empty when there is no table.
    *
    * Held by the controller between edits, so a render reading this five
@@ -51411,6 +52115,9 @@ export type CustomElements = {
    * names an element, and the chart is a generic around its plot: written
    * on the host, the name reached nobody. The plot takes it, as Heatmap's
    * strip always did. (property only) (readonly)
+   * - `readingsKnown`: Whether the readings have been looked for: false on the server and
+   * while hydrating, where no table is resolved and no data is read. A
+   * chart says it has no readings only once this is true. (property only) (readonly)
    * - `sourceRows`: Every row of the table, with each cell's text and number.
    *
    * This is where a tooltip's content comes from, and it is deliberately not
@@ -51457,6 +52164,13 @@ export type CustomElements = {
    * - `helix-reading-change`: The reading shown moved, or was put away: `index` is the row, or `-1` for none, with its `label`, the `series` the keys rest on, and the `pointerType` that moved it.
    * - `helix-reading-press`: A reading was clicked, tapped, or pressed with Enter or Space, with the same detail as `helix-reading-change`.
    *
+   * ## Slots
+   *
+   * Areas where markup can be added to the component.
+   *
+   * - `empty`: Content shown in place of the drawing when the table has no readings, such as a link to add the first. Falls back to `empty-text`.
+   * - `loading`: Content shown in place of the drawing while `loading` is set and there are no readings yet. Falls back to `loading-text`.
+   *
    * ## Methods
    *
    * Methods that can be called to access component functionality.
@@ -51506,8 +52220,10 @@ export type CustomElements = {
    *
    * Custom selectors for styling elements within the component.
    *
+   * - `empty`: The words in place of the drawing when the table has no readings: the `empty` slot, falling back to `empty-text`. Not drawn while the table cannot be read yet, on the server and during hydration.
    * - `gridline`: One line across the plot, drawn when `gridlines` is set.
    * - `live`: The readout: a polite live region that says the row the keys moved to. Hide it visually.
+   * - `loading`: The words in place of the drawing while `loading` is set and there are no readings: the `loading` slot, falling back to `loading-text`.
    * - `mark`: The invisible point the tooltip is anchored to.
    * - `plane`: The grid that holds the plot, both axes, and their names. It runs left to right on every page.
    * - `plot`: The drawing, which takes focus to be read by key.
@@ -59872,6 +60588,16 @@ export type CustomElementsSolidJs = {
    * tap or key, and `helix-reading-press` says a reading was clicked, tapped, or
    * pressed with Enter or Space, for a page that opens what a reading stands for.
    *
+   * **`data` takes the readings as data** where the page has no table to point
+   * `for` at, in a table's shape: the column headings, then one row per reading
+   * with its label first. A table is still the better source where the page can
+   * show one, since it reads before any script runs.
+   *
+   * **A chart with nothing to draw says so.** A table with no readings shows
+   * `empty-text`, "No readings", in the plot, and `loading` shows `loading-text`
+   * there until readings arrive. The `empty` and `loading` slots take markup in
+   * their place, such as a link to add the first reading.
+   *
    * ## Attributes & Properties
    *
    * Component attributes and properties that can be applied to the element or by using JavaScript.
@@ -59918,6 +60644,16 @@ export type CustomElementsSolidJs = {
    *
    * Absent draws none: bands read as a composition need no numbers beside
    * them, and the tooltip and the table hold every reading.
+   * - `empty-text`/`emptyText`: The words shown in place of the drawing when the table has no readings,
+   * and the fallback of the `empty` slot.
+   * - `loading`: Whether the readings are still on their way. The chart shows
+   * `loading-text` in place of an empty drawing until it has readings.
+   *
+   * Reflected, so a stylesheet can treat the chart while it waits. A chart
+   * that already has readings keeps drawing them, so a refresh does not
+   * blank it.
+   * - `loading-text`/`loadingText`: The words shown in place of the drawing while `loading` is set and
+   * there are no readings yet, and the fallback of the `loading` slot.
    * - `for`: The id of the table to read.
    *
    * Names a table in the same tree, so a chart inside another component's
@@ -59948,6 +60684,28 @@ export type CustomElementsSolidJs = {
    * cannot be cast onto across unrelated classes, so it would be invisible to
    * every chart that needs it. Reading where a pointer is resting is a fair
    * thing to ask a chart anyway. (property only) (readonly)
+   * - `data`: The readings as data, in the shape of a table, where the page has no
+   * table to point `for` at. `for` wins where both are set.
+   *
+   * ```js
+   * chart.data = {
+   *   caption: 'Sessions by channel',
+   *   columns: ['Month', 'Direct', 'Referral'],
+   *   rows: [['Jan', 10, 4], ['Feb', 20, 8]],
+   * }
+   * ```
+   *
+   * The first column holds each row's label and every column after it a
+   * series, as in a table. A cell is a number, words, `null` for a blank,
+   * or `{ value, text }` for a number shown as words, such as `$128k`. A
+   * number is shown in `locale`.
+   *
+   * **A table is still the better source where the page can show one**:
+   * it reads with no script and before hydration, and a reader can sort and
+   * copy it. Data is drawn on the client only, so a server serves the
+   * frame, and the summary, the keys and the readout are then the whole of
+   * what a screen reader is given. Set a new object to redraw: the chart
+   * does not look inside the one it has. (property only)
    * - `series`: The table's columns, one series each. Empty when there is no table.
    *
    * Held by the controller between edits, so a render reading this five
@@ -59964,6 +60722,9 @@ export type CustomElementsSolidJs = {
    * names an element, and the chart is a generic around its plot: written
    * on the host, the name reached nobody. The plot takes it, as Heatmap's
    * strip always did. (property only) (readonly)
+   * - `readingsKnown`: Whether the readings have been looked for: false on the server and
+   * while hydrating, where no table is resolved and no data is read. A
+   * chart says it has no readings only once this is true. (property only) (readonly)
    * - `sourceRows`: Every row of the table, with each cell's text and number.
    *
    * This is where a tooltip's content comes from, and it is deliberately not
@@ -60010,6 +60771,13 @@ export type CustomElementsSolidJs = {
    * - `helix-reading-change`: The reading shown moved, or was put away: `index` is the row, or `-1` for none, with its `label`, the `series` the keys rest on, and the `pointerType` that moved it.
    * - `helix-reading-press`: A reading was clicked, tapped, or pressed with Enter or Space, with the same detail as `helix-reading-change`.
    *
+   * ## Slots
+   *
+   * Areas where markup can be added to the component.
+   *
+   * - `empty`: Content shown in place of the drawing when the table has no readings, such as a link to add the first. Falls back to `empty-text`.
+   * - `loading`: Content shown in place of the drawing while `loading` is set and there are no readings yet. Falls back to `loading-text`.
+   *
    * ## Methods
    *
    * Methods that can be called to access component functionality.
@@ -60059,12 +60827,14 @@ export type CustomElementsSolidJs = {
    * - `area`: One part's band.
    * - `axis`: The numbers of the scale beside the plot, under `value-axis`.
    * - `baseline`: The rule at zero, which is the floor of the drawing.
+   * - `empty`: The words in place of the drawing when the table has no readings: the `empty` slot, falling back to `empty-text`. Not drawn while the table cannot be read yet, on the server and during hydration.
    * - `gridline`: One rule across the plot, under `gridlines`.
    * - `guide`: A rule down the reading a pointer is resting on.
    * - `label`: One reading's name.
    * - `labels`: The row of reading names.
    * - `line`: The top edge of one part's band.
    * - `live`: The readout: a polite live region that says the reading the keys moved to. Hide it visually.
+   * - `loading`: The words in place of the drawing while `loading` is set and there are no readings: the `loading` slot, falling back to `loading-text`.
    * - `mark`: The invisible point the tooltip is anchored to.
    * - `plot`: The drawing, which takes focus to be read by key.
    * - `summary`: The total and each part's share at the latest reading, written as a sentence for screen readers.
@@ -60460,6 +61230,16 @@ export type CustomElementsSolidJs = {
    * tap or key, and `helix-reading-press` says a reading was clicked, tapped, or
    * pressed with Enter or Space, for a page that opens what a reading stands for.
    *
+   * **`data` takes the readings as data** where the page has no table to point
+   * `for` at, in a table's shape: the column headings, then one row per reading
+   * with its label first. A table is still the better source where the page can
+   * show one, since it reads before any script runs.
+   *
+   * **A chart with nothing to draw says so.** A table with no readings shows
+   * `empty-text`, "No readings", in the plot, and `loading` shows `loading-text`
+   * there until readings arrive. The `empty` and `loading` slots take markup in
+   * their place, such as a link to add the first reading.
+   *
    * ## Attributes & Properties
    *
    * Component attributes and properties that can be applied to the element or by using JavaScript.
@@ -60565,6 +61345,16 @@ export type CustomElementsSolidJs = {
    *
    * Absent draws none with one scale, since bars compared with each other need
    * no numbers. With `secondary` both scales are drawn whatever this says.
+   * - `empty-text`/`emptyText`: The words shown in place of the drawing when the table has no readings,
+   * and the fallback of the `empty` slot.
+   * - `loading`: Whether the readings are still on their way. The chart shows
+   * `loading-text` in place of an empty drawing until it has readings.
+   *
+   * Reflected, so a stylesheet can treat the chart while it waits. A chart
+   * that already has readings keeps drawing them, so a refresh does not
+   * blank it.
+   * - `loading-text`/`loadingText`: The words shown in place of the drawing while `loading` is set and
+   * there are no readings yet, and the fallback of the `loading` slot.
    * - `for`: The id of the table to read.
    *
    * Names a table in the same tree, so a chart inside another component's
@@ -60595,6 +61385,28 @@ export type CustomElementsSolidJs = {
    * cannot be cast onto across unrelated classes, so it would be invisible to
    * every chart that needs it. Reading where a pointer is resting is a fair
    * thing to ask a chart anyway. (property only) (readonly)
+   * - `data`: The readings as data, in the shape of a table, where the page has no
+   * table to point `for` at. `for` wins where both are set.
+   *
+   * ```js
+   * chart.data = {
+   *   caption: 'Sessions by channel',
+   *   columns: ['Month', 'Direct', 'Referral'],
+   *   rows: [['Jan', 10, 4], ['Feb', 20, 8]],
+   * }
+   * ```
+   *
+   * The first column holds each row's label and every column after it a
+   * series, as in a table. A cell is a number, words, `null` for a blank,
+   * or `{ value, text }` for a number shown as words, such as `$128k`. A
+   * number is shown in `locale`.
+   *
+   * **A table is still the better source where the page can show one**:
+   * it reads with no script and before hydration, and a reader can sort and
+   * copy it. Data is drawn on the client only, so a server serves the
+   * frame, and the summary, the keys and the readout are then the whole of
+   * what a screen reader is given. Set a new object to redraw: the chart
+   * does not look inside the one it has. (property only)
    * - `series`: The table's columns, one series each. Empty when there is no table.
    *
    * Held by the controller between edits, so a render reading this five
@@ -60611,6 +61423,9 @@ export type CustomElementsSolidJs = {
    * names an element, and the chart is a generic around its plot: written
    * on the host, the name reached nobody. The plot takes it, as Heatmap's
    * strip always did. (property only) (readonly)
+   * - `readingsKnown`: Whether the readings have been looked for: false on the server and
+   * while hydrating, where no table is resolved and no data is read. A
+   * chart says it has no readings only once this is true. (property only) (readonly)
    * - `sourceRows`: Every row of the table, with each cell's text and number.
    *
    * This is where a tooltip's content comes from, and it is deliberately not
@@ -60657,6 +61472,13 @@ export type CustomElementsSolidJs = {
    * - `helix-reading-change`: The reading shown moved, or was put away: `index` is the row, or `-1` for none, with its `label`, the `series` the keys rest on, and the `pointerType` that moved it.
    * - `helix-reading-press`: A reading was clicked, tapped, or pressed with Enter or Space, with the same detail as `helix-reading-change`.
    *
+   * ## Slots
+   *
+   * Areas where markup can be added to the component.
+   *
+   * - `empty`: Content shown in place of the drawing when the table has no readings, such as a link to add the first. Falls back to `empty-text`.
+   * - `loading`: Content shown in place of the drawing while `loading` is set and there are no readings yet. Falls back to `loading-text`.
+   *
    * ## Methods
    *
    * Methods that can be called to access component functionality.
@@ -60711,6 +61533,7 @@ export type CustomElementsSolidJs = {
    * - `bar-wash-end`: The far stop of a bar's gradient, where one is used.
    * - `bar-wash-start`: The stop of a bar's gradient at its base.
    * - `baseline`: The line the columns stand on.
+   * - `empty`: The words in place of the drawing when the table has no readings: the `empty` slot, falling back to `empty-text`. Not drawn while the table cannot be read yet, on the server and during hydration.
    * - `gridline`: One gridline across the plot, drawn when `gridlines` is set.
    * - `group`: One category's columns, together.
    * - `group-active`: The group the tooltip describes. Set together with `group`.
@@ -60718,6 +61541,7 @@ export type CustomElementsSolidJs = {
    * - `labels`: The row of category names.
    * - `line`: A series drawn as a line, named in `lines`.
    * - `live`: The readout: a polite live region that says the reading the keys moved to. Hide it visually.
+   * - `loading`: The words in place of the drawing while `loading` is set and there are no readings: the `loading` slot, falling back to `loading-text`.
    * - `mark`: The invisible point the tooltip is anchored to.
    * - `plot`: The drawing, which takes focus to be read by key.
    * - `summary`: The chart's name and each series' highest reading, written as a sentence for screen readers. Hide it visually.
@@ -67319,6 +68143,28 @@ export type CustomElementsSolidJs = {
    * cannot be cast onto across unrelated classes, so it would be invisible to
    * every chart that needs it. Reading where a pointer is resting is a fair
    * thing to ask a chart anyway. (property only) (readonly)
+   * - `data`: The readings as data, in the shape of a table, where the page has no
+   * table to point `for` at. `for` wins where both are set.
+   *
+   * ```js
+   * chart.data = {
+   *   caption: 'Sessions by channel',
+   *   columns: ['Month', 'Direct', 'Referral'],
+   *   rows: [['Jan', 10, 4], ['Feb', 20, 8]],
+   * }
+   * ```
+   *
+   * The first column holds each row's label and every column after it a
+   * series, as in a table. A cell is a number, words, `null` for a blank,
+   * or `{ value, text }` for a number shown as words, such as `$128k`. A
+   * number is shown in `locale`.
+   *
+   * **A table is still the better source where the page can show one**:
+   * it reads with no script and before hydration, and a reader can sort and
+   * copy it. Data is drawn on the client only, so a server serves the
+   * frame, and the summary, the keys and the readout are then the whole of
+   * what a screen reader is given. Set a new object to redraw: the chart
+   * does not look inside the one it has. (property only)
    * - `series`: The table's columns, one series each. Empty when there is no table.
    *
    * Held by the controller between edits, so a render reading this five
@@ -67335,6 +68181,9 @@ export type CustomElementsSolidJs = {
    * names an element, and the chart is a generic around its plot: written
    * on the host, the name reached nobody. The plot takes it, as Heatmap's
    * strip always did. (property only) (readonly)
+   * - `readingsKnown`: Whether the readings have been looked for: false on the server and
+   * while hydrating, where no table is resolved and no data is read. A
+   * chart says it has no readings only once this is true. (property only) (readonly)
    * - `sourceRows`: Every row of the table, with each cell's text and number.
    *
    * This is where a tooltip's content comes from, and it is deliberately not
@@ -69881,6 +70730,28 @@ export type CustomElementsSolidJs = {
    * cannot be cast onto across unrelated classes, so it would be invisible to
    * every chart that needs it. Reading where a pointer is resting is a fair
    * thing to ask a chart anyway. (property only) (readonly)
+   * - `data`: The readings as data, in the shape of a table, where the page has no
+   * table to point `for` at. `for` wins where both are set.
+   *
+   * ```js
+   * chart.data = {
+   *   caption: 'Sessions by channel',
+   *   columns: ['Month', 'Direct', 'Referral'],
+   *   rows: [['Jan', 10, 4], ['Feb', 20, 8]],
+   * }
+   * ```
+   *
+   * The first column holds each row's label and every column after it a
+   * series, as in a table. A cell is a number, words, `null` for a blank,
+   * or `{ value, text }` for a number shown as words, such as `$128k`. A
+   * number is shown in `locale`.
+   *
+   * **A table is still the better source where the page can show one**:
+   * it reads with no script and before hydration, and a reader can sort and
+   * copy it. Data is drawn on the client only, so a server serves the
+   * frame, and the summary, the keys and the readout are then the whole of
+   * what a screen reader is given. Set a new object to redraw: the chart
+   * does not look inside the one it has. (property only)
    * - `series`: The table's columns, one series each. Empty when there is no table.
    *
    * Held by the controller between edits, so a render reading this five
@@ -69897,6 +70768,9 @@ export type CustomElementsSolidJs = {
    * names an element, and the chart is a generic around its plot: written
    * on the host, the name reached nobody. The plot takes it, as Heatmap's
    * strip always did. (property only) (readonly)
+   * - `readingsKnown`: Whether the readings have been looked for: false on the server and
+   * while hydrating, where no table is resolved and no data is read. A
+   * chart says it has no readings only once this is true. (property only) (readonly)
    * - `sourceRows`: Every row of the table, with each cell's text and number.
    *
    * This is where a tooltip's content comes from, and it is deliberately not
@@ -71558,6 +72432,16 @@ export type CustomElementsSolidJs = {
    * tap or key, and `helix-reading-press` says a reading was clicked, tapped, or
    * pressed with Enter or Space, for a page that opens what a reading stands for.
    *
+   * **`data` takes the readings as data** where the page has no table to point
+   * `for` at, in a table's shape: the column headings, then one row per reading
+   * with its label first. A table is still the better source where the page can
+   * show one, since it reads before any script runs.
+   *
+   * **A chart with nothing to draw says so.** A table with no readings shows
+   * `empty-text`, "No readings", in the plot, and `loading` shows `loading-text`
+   * there until readings arrive. The `empty` and `loading` slots take markup in
+   * their place, such as a link to add the first reading.
+   *
    * ## Attributes & Properties
    *
    * Component attributes and properties that can be applied to the element or by using JavaScript.
@@ -71668,6 +72552,16 @@ export type CustomElementsSolidJs = {
    * Set it where the distance from nothing is the point rather than the shape,
    * and accept that a series which never approaches zero becomes a flat rule
    * near the top of the box.
+   * - `empty-text`/`emptyText`: The words shown in place of the drawing when the table has no readings,
+   * and the fallback of the `empty` slot.
+   * - `loading`: Whether the readings are still on their way. The chart shows
+   * `loading-text` in place of an empty drawing until it has readings.
+   *
+   * Reflected, so a stylesheet can treat the chart while it waits. A chart
+   * that already has readings keeps drawing them, so a refresh does not
+   * blank it.
+   * - `loading-text`/`loadingText`: The words shown in place of the drawing while `loading` is set and
+   * there are no readings yet, and the fallback of the `loading` slot.
    * - `for`: The id of the table to read.
    *
    * Names a table in the same tree, so a chart inside another component's
@@ -71698,6 +72592,28 @@ export type CustomElementsSolidJs = {
    * cannot be cast onto across unrelated classes, so it would be invisible to
    * every chart that needs it. Reading where a pointer is resting is a fair
    * thing to ask a chart anyway. (property only) (readonly)
+   * - `data`: The readings as data, in the shape of a table, where the page has no
+   * table to point `for` at. `for` wins where both are set.
+   *
+   * ```js
+   * chart.data = {
+   *   caption: 'Sessions by channel',
+   *   columns: ['Month', 'Direct', 'Referral'],
+   *   rows: [['Jan', 10, 4], ['Feb', 20, 8]],
+   * }
+   * ```
+   *
+   * The first column holds each row's label and every column after it a
+   * series, as in a table. A cell is a number, words, `null` for a blank,
+   * or `{ value, text }` for a number shown as words, such as `$128k`. A
+   * number is shown in `locale`.
+   *
+   * **A table is still the better source where the page can show one**:
+   * it reads with no script and before hydration, and a reader can sort and
+   * copy it. Data is drawn on the client only, so a server serves the
+   * frame, and the summary, the keys and the readout are then the whole of
+   * what a screen reader is given. Set a new object to redraw: the chart
+   * does not look inside the one it has. (property only)
    * - `series`: The table's columns, one series each. Empty when there is no table.
    *
    * Held by the controller between edits, so a render reading this five
@@ -71714,6 +72630,9 @@ export type CustomElementsSolidJs = {
    * names an element, and the chart is a generic around its plot: written
    * on the host, the name reached nobody. The plot takes it, as Heatmap's
    * strip always did. (property only) (readonly)
+   * - `readingsKnown`: Whether the readings have been looked for: false on the server and
+   * while hydrating, where no table is resolved and no data is read. A
+   * chart says it has no readings only once this is true. (property only) (readonly)
    * - `sourceRows`: Every row of the table, with each cell's text and number.
    *
    * This is where a tooltip's content comes from, and it is deliberately not
@@ -71760,6 +72679,13 @@ export type CustomElementsSolidJs = {
    * - `helix-reading-change`: The reading shown moved, or was put away: `index` is the row, or `-1` for none, with its `label`, the `series` the keys rest on, and the `pointerType` that moved it.
    * - `helix-reading-press`: A reading was clicked, tapped, or pressed with Enter or Space, with the same detail as `helix-reading-change`.
    *
+   * ## Slots
+   *
+   * Areas where markup can be added to the component.
+   *
+   * - `empty`: Content shown in place of the drawing when the table has no readings, such as a link to add the first. Falls back to `empty-text`.
+   * - `loading`: Content shown in place of the drawing while `loading` is set and there are no readings yet. Falls back to `loading-text`.
+   *
    * ## Methods
    *
    * Methods that can be called to access component functionality.
@@ -71812,6 +72738,7 @@ export type CustomElementsSolidJs = {
    * - `axis`: The numbers of the scale beside the plot, under `value-axis`.
    * - `band`: The band around the reading under the pointer.
    * - `baseline`: The rule at zero, where zero is inside the range.
+   * - `empty`: The words in place of the drawing when the table has no readings: the `empty` slot, falling back to `empty-text`. Not drawn while the table cannot be read yet, on the server and during hydration.
    * - `gridline`: One rule across the plot, under `gridlines`.
    * - `guide`: A rule down the reading a pointer is resting on.
    * - `label`: One reading's name.
@@ -71819,6 +72746,7 @@ export type CustomElementsSolidJs = {
    * - `line`: The line for one series.
    * - `line-dashed`: A `line` whose series `dashed` names. Set alongside `line`.
    * - `live`: The readout: a polite live region that says the reading the keys moved to. Hide it visually.
+   * - `loading`: The words in place of the drawing while `loading` is set and there are no readings: the `loading` slot, falling back to `loading-text`.
    * - `mark`: The invisible point the tooltip is anchored to.
    * - `marker`: The mark on one reading, under `markers`, and on a reading with a blank on either side. Placed with `inset-inline-start` and `inset-block-start`, and carries its series color as `--chart-series`.
    * - `marker-lone`: A `marker` on a reading with a blank on either side, which no line reaches. Set alongside `marker`.
@@ -72614,6 +73542,11 @@ export type CustomElementsSolidJs = {
    * Draws two concentric circles: a track and a moving arc. The track shows the
    * arc as a proportion of a whole, and costs one element.
    *
+   * **For work whose length is known, use `Progress` with `shape="ring"`.** It
+   * draws the same ring filled to the value, says the value as a progress bar
+   * does, and says when the work is complete. A loader claims no proportion, so
+   * it takes no value.
+   *
    * **The center is a slot, empty by default.** Put your logo there once, where
    * your app wraps the loader. When nothing is slotted, nothing extra is
    * rendered.
@@ -77182,6 +78115,15 @@ export type CustomElementsSolidJs = {
    *
    * The fill is a fraction of the track, written as a custom property.
    *
+   * **The reading is said in the words the bar would show**: a whole percentage
+   * of the range in `locale`, the reading `format-options` writes, or
+   * `value-text`, as `aria-valuetext` beside the number.
+   *
+   * **Words set in the default slot are drawn on the bar**, or in the middle of a
+   * ring, such as `62%` or `3 of 8`, and are what the bar says as its reading
+   * where `value-text` is not set. While there are any, the bar carries
+   * `:state(content)`, so a sheet can make room for them.
+   *
    * **Reaching `max` is said and sent.** When the value arrives at `max` from
    * below, the bar says `complete-label`, "Complete" by default, in a polite
    * `live` region and sends `helix-complete`, so a reader hears that the work is
@@ -77208,7 +78150,8 @@ export type CustomElementsSolidJs = {
    *
    * A `percent` style writes the share of the range, and any other the value
    * itself, so the example says "18 GB". Absent is a whole percentage. The
-   * words are announced as well as shown. `value-text` still wins.
+   * words are announced whether or not `show-value` shows them. `value-text`
+   * still wins.
    * - `indeterminate`: Whether the length of the task is unknown. The bar then shows activity
    * without a value.
    *
@@ -77297,6 +78240,7 @@ export type CustomElementsSolidJs = {
    *
    * Areas where markup can be added to the component.
    *
+   * - `(default)`: Words drawn on the bar, or in the middle of a ring, such as the reading. Said as the reading where `value-text` is not set.
    * - `label`: A visible label. Its words name the progress bar in place of `label`.
    *
    * ## CSS Custom Properties
@@ -77309,6 +78253,7 @@ export type CustomElementsSolidJs = {
    *
    * Custom selectors for styling elements within the component.
    *
+   * - `content`: The box holding the words of the default slot, over the track or in the middle of the ring. Carries `--progress-fraction`.
    * - `groove`: The unfilled circle under the ring's filled arc.
    * - `indicator`: The filled part that shows the work done.
    * - `live`: A polite region that says `complete-label` when the work is done, rendered from that moment. Hide it visually.
@@ -77320,6 +78265,7 @@ export type CustomElementsSolidJs = {
    * These can be used to apply styling when a component is in a given state.
    *
    * - `complete`: The value is at `max` and the bar is not indeterminate.
+   * - `content`: Words are set in the default slot.
    * - `settled`: Set one frame after the first render. Transitions wait for it, so an element does not animate its own arrival.
    */
   "helix-headless-progress": Partial<
@@ -78269,6 +79215,16 @@ export type CustomElementsSolidJs = {
    * tap or key, and `helix-reading-press` says a reading was clicked, tapped, or
    * pressed with Enter or Space, for a page that opens what a reading stands for.
    *
+   * **`data` takes the readings as data** where the page has no table to point
+   * `for` at, in a table's shape: the column headings, then one row per reading
+   * with its label first. A table is still the better source where the page can
+   * show one, since it reads before any script runs.
+   *
+   * **A chart with nothing to draw says so.** A table with no readings shows
+   * `empty-text`, "No readings", in the plot, and `loading` shows `loading-text`
+   * there until readings arrive. The `empty` and `loading` slots take markup in
+   * their place, such as a link to add the first reading.
+   *
    * ## Attributes & Properties
    *
    * Component attributes and properties that can be applied to the element or by using JavaScript.
@@ -78304,6 +79260,16 @@ export type CustomElementsSolidJs = {
    * Absent draws none. A series with fewer than two points, or with every
    * point at one measure across, has no line to draw. The summary already
    * gives each series' correlation, which says how near the points are to it.
+   * - `empty-text`/`emptyText`: The words shown in place of the drawing when the table has no readings,
+   * and the fallback of the `empty` slot.
+   * - `loading`: Whether the readings are still on their way. The chart shows
+   * `loading-text` in place of an empty drawing until it has readings.
+   *
+   * Reflected, so a stylesheet can treat the chart while it waits. A chart
+   * that already has readings keeps drawing them, so a refresh does not
+   * blank it.
+   * - `loading-text`/`loadingText`: The words shown in place of the drawing while `loading` is set and
+   * there are no readings yet, and the fallback of the `loading` slot.
    * - `for`: The id of the table to read.
    *
    * Names a table in the same tree, so a chart inside another component's
@@ -78334,6 +79300,28 @@ export type CustomElementsSolidJs = {
    * cannot be cast onto across unrelated classes, so it would be invisible to
    * every chart that needs it. Reading where a pointer is resting is a fair
    * thing to ask a chart anyway. (property only) (readonly)
+   * - `data`: The readings as data, in the shape of a table, where the page has no
+   * table to point `for` at. `for` wins where both are set.
+   *
+   * ```js
+   * chart.data = {
+   *   caption: 'Sessions by channel',
+   *   columns: ['Month', 'Direct', 'Referral'],
+   *   rows: [['Jan', 10, 4], ['Feb', 20, 8]],
+   * }
+   * ```
+   *
+   * The first column holds each row's label and every column after it a
+   * series, as in a table. A cell is a number, words, `null` for a blank,
+   * or `{ value, text }` for a number shown as words, such as `$128k`. A
+   * number is shown in `locale`.
+   *
+   * **A table is still the better source where the page can show one**:
+   * it reads with no script and before hydration, and a reader can sort and
+   * copy it. Data is drawn on the client only, so a server serves the
+   * frame, and the summary, the keys and the readout are then the whole of
+   * what a screen reader is given. Set a new object to redraw: the chart
+   * does not look inside the one it has. (property only)
    * - `series`: The table's columns, one series each. Empty when there is no table.
    *
    * Held by the controller between edits, so a render reading this five
@@ -78350,6 +79338,9 @@ export type CustomElementsSolidJs = {
    * names an element, and the chart is a generic around its plot: written
    * on the host, the name reached nobody. The plot takes it, as Heatmap's
    * strip always did. (property only) (readonly)
+   * - `readingsKnown`: Whether the readings have been looked for: false on the server and
+   * while hydrating, where no table is resolved and no data is read. A
+   * chart says it has no readings only once this is true. (property only) (readonly)
    * - `sourceRows`: Every row of the table, with each cell's text and number.
    *
    * This is where a tooltip's content comes from, and it is deliberately not
@@ -78396,6 +79387,13 @@ export type CustomElementsSolidJs = {
    * - `helix-reading-change`: The reading shown moved, or was put away: `index` is the row, or `-1` for none, with its `label`, the `series` the keys rest on, and the `pointerType` that moved it.
    * - `helix-reading-press`: A reading was clicked, tapped, or pressed with Enter or Space, with the same detail as `helix-reading-change`.
    *
+   * ## Slots
+   *
+   * Areas where markup can be added to the component.
+   *
+   * - `empty`: Content shown in place of the drawing when the table has no readings, such as a link to add the first. Falls back to `empty-text`.
+   * - `loading`: Content shown in place of the drawing while `loading` is set and there are no readings yet. Falls back to `loading-text`.
+   *
    * ## Methods
    *
    * Methods that can be called to access component functionality.
@@ -78445,8 +79443,10 @@ export type CustomElementsSolidJs = {
    *
    * Custom selectors for styling elements within the component.
    *
+   * - `empty`: The words in place of the drawing when the table has no readings: the `empty` slot, falling back to `empty-text`. Not drawn while the table cannot be read yet, on the server and during hydration.
    * - `gridline`: One line across the plot, drawn when `gridlines` is set.
    * - `live`: The readout: a polite live region that says the row the keys moved to. Hide it visually.
+   * - `loading`: The words in place of the drawing while `loading` is set and there are no readings: the `loading` slot, falling back to `loading-text`.
    * - `mark`: The invisible point the tooltip is anchored to.
    * - `plane`: The grid that holds the plot, both axes, and their names. It runs left to right on every page.
    * - `plot`: The drawing, which takes focus to be read by key.