@fusion.dev/helix 0.152.0 → 0.153.0

package/types/jsx.d.ts

@@ -1255,6 +1255,25 @@ export type HelixAreaChartHelixReadingPressElementEvent =
   HelixAreaChartElementEvent<HelixReadingPressEvent>;
 
 export type HelixAreaChartProps = {
+  /** The words shown in place of the drawing when the table has no readings,
+and the fallback of the `empty` slot. */
+  "empty-text"?: (HelixAreaChart["emptyText"]) | undefined;
+  /** The words shown in place of the drawing when the table has no readings,
+and the fallback of the `empty` slot. */
+  emptyText?: (HelixAreaChart["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?: (HelixAreaChart["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"?: (HelixAreaChart["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?: (HelixAreaChart["loadingText"]) | undefined;
   /** The id of the table to read.
 
 Names a table in the same tree, so a chart inside another component's
@@ -1352,6 +1371,29 @@ 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?: (HelixAreaChart["valueAxis"]) | 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?: (HelixAreaChart["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"?: ((
@@ -1364,6 +1406,25 @@ them, and the tooltip and the table hold every reading. */
 };
 
 export type HelixAreaChartSolidJsProps = {
+  /** The words shown in place of the drawing when the table has no readings,
+and the fallback of the `empty` slot. */
+  "attr:empty-text"?: (HelixAreaChart["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"?: (HelixAreaChart["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"?: (HelixAreaChart["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"?: (HelixAreaChart["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"?: (HelixAreaChart["loadingText"]) | undefined;
   /** The id of the table to read.
 
 Names a table in the same tree, so a chart inside another component's
@@ -1461,6 +1522,29 @@ 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"?: (HelixAreaChart["valueAxis"]) | 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"?: (HelixAreaChart["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: HelixAreaChartHelixReadingChangeElementEvent,
@@ -2218,6 +2302,25 @@ every component in the library and mean something on one. `wash` because
 that is what the tier below already calls it, in `--chart-bar-wash` and in
 the `bar-wash-start` and `bar-wash-end` stops. */
   wash?: (HelixBarChart["wash"]) | undefined;
+  /** The words shown in place of the drawing when the table has no readings,
+and the fallback of the `empty` slot. */
+  "empty-text"?: (HelixBarChart["emptyText"]) | undefined;
+  /** The words shown in place of the drawing when the table has no readings,
+and the fallback of the `empty` slot. */
+  emptyText?: (HelixBarChart["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?: (HelixBarChart["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"?: (HelixBarChart["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?: (HelixBarChart["loadingText"]) | undefined;
   /** The id of the table to read.
 
 Names a table in the same tree, so a chart inside another component's
@@ -2377,6 +2480,29 @@ 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?: (HelixBarChart["valueAxis"]) | 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?: (HelixBarChart["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"?: ((
@@ -2494,6 +2620,25 @@ every component in the library and mean something on one. `wash` because
 that is what the tier below already calls it, in `--chart-bar-wash` and in
 the `bar-wash-start` and `bar-wash-end` stops. */
   "prop:wash"?: (HelixBarChart["wash"]) | 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"?: (HelixBarChart["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"?: (HelixBarChart["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"?: (HelixBarChart["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"?: (HelixBarChart["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"?: (HelixBarChart["loadingText"]) | undefined;
   /** The id of the table to read.
 
 Names a table in the same tree, so a chart inside another component's
@@ -2653,6 +2798,29 @@ 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"?: (HelixBarChart["valueAxis"]) | 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"?: (HelixBarChart["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: HelixBarChartHelixReadingChangeElementEvent,
@@ -2669,6 +2837,42 @@ no numbers. With `secondary` both scales are drawn whatever this says. */
 };
 
 export type HelixBlockquoteProps = {
+  /** How the passage and its attribution align, set as `text-align`.
+
+`center` for a pull quote in the middle of a column and `end` for one
+against its far edge. Under either, the mark `marks` draws stands over
+the first line. Absent aligns as the prose around it does.
+
+Named for the CSS property it sets, as `Text.textAlign` is: `align` alone
+is a legacy HTML attribute the browser maps to `text-align` by itself,
+and it has no `start` or `end`. */
+  "text-align"?: (HelixBlockquote["textAlign"]) | undefined;
+  /** How the passage and its attribution align, set as `text-align`.
+
+`center` for a pull quote in the middle of a column and `end` for one
+against its far edge. Under either, the mark `marks` draws stands over
+the first line. Absent aligns as the prose around it does.
+
+Named for the CSS property it sets, as `Text.textAlign` is: `align` alone
+is a legacy HTML attribute the browser maps to `text-align` by itself,
+and it has no `start` or `end`. */
+  textAlign?: (HelixBlockquote["textAlign"]) | undefined;
+  /** How the passage's lines break, set as `text-wrap`.
+
+`balance` evens out the length of every line, which suits a pull quote of
+a few lines in display type. `pretty` avoids a last line of one short
+word, for a longer passage. Absent, the lines break as the browser breaks
+them. The same name and values `Text` takes, but `nowrap`, a passage being
+more than one line. */
+  "text-wrap"?: (HelixBlockquote["textWrap"]) | undefined;
+  /** How the passage's lines break, set as `text-wrap`.
+
+`balance` evens out the length of every line, which suits a pull quote of
+a few lines in display type. `pretty` avoids a last line of one short
+word, for a longer passage. Absent, the lines break as the browser breaks
+them. The same name and values `Text` takes, but `nowrap`, a passage being
+more than one line. */
+  textWrap?: (HelixBlockquote["textWrap"]) | undefined;
   /** Who said it, and where, as words, such as "Maria Lopez, operations
 manager". The `attribution` slot replaces them, for markup such as a link.
 
@@ -2685,6 +2889,42 @@ element's language. Leave the marks out of the text. */
 };
 
 export type HelixBlockquoteSolidJsProps = {
+  /** How the passage and its attribution align, set as `text-align`.
+
+`center` for a pull quote in the middle of a column and `end` for one
+against its far edge. Under either, the mark `marks` draws stands over
+the first line. Absent aligns as the prose around it does.
+
+Named for the CSS property it sets, as `Text.textAlign` is: `align` alone
+is a legacy HTML attribute the browser maps to `text-align` by itself,
+and it has no `start` or `end`. */
+  "attr:text-align"?: (HelixBlockquote["textAlign"]) | undefined;
+  /** How the passage and its attribution align, set as `text-align`.
+
+`center` for a pull quote in the middle of a column and `end` for one
+against its far edge. Under either, the mark `marks` draws stands over
+the first line. Absent aligns as the prose around it does.
+
+Named for the CSS property it sets, as `Text.textAlign` is: `align` alone
+is a legacy HTML attribute the browser maps to `text-align` by itself,
+and it has no `start` or `end`. */
+  "prop:textAlign"?: (HelixBlockquote["textAlign"]) | undefined;
+  /** How the passage's lines break, set as `text-wrap`.
+
+`balance` evens out the length of every line, which suits a pull quote of
+a few lines in display type. `pretty` avoids a last line of one short
+word, for a longer passage. Absent, the lines break as the browser breaks
+them. The same name and values `Text` takes, but `nowrap`, a passage being
+more than one line. */
+  "attr:text-wrap"?: (HelixBlockquote["textWrap"]) | undefined;
+  /** How the passage's lines break, set as `text-wrap`.
+
+`balance` evens out the length of every line, which suits a pull quote of
+a few lines in display type. `pretty` avoids a last line of one short
+word, for a longer passage. Absent, the lines break as the browser breaks
+them. The same name and values `Text` takes, but `nowrap`, a passage being
+more than one line. */
+  "prop:textWrap"?: (HelixBlockquote["textWrap"]) | undefined;
   /** Who said it, and where, as words, such as "Maria Lopez, operations
 manager". The `attribution` slot replaces them, for markup such as a link.
 
@@ -12935,6 +13175,29 @@ rotation that puts the first slice at nine o'clock, the aspect ratio of a
 box that is no longer square, and where the middle sits once the bottom of
 the circle is not drawn. */
   sweep?: (HelixDonutChart["sweep"]) | 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?: (HelixDonutChart["data"]) | undefined;
 };
 
 export type HelixDonutChartSolidJsProps = {
@@ -13079,6 +13342,29 @@ rotation that puts the first slice at nine o'clock, the aspect ratio of a
 box that is no longer square, and where the middle sits once the bottom of
 the circle is not drawn. */
   "prop:sweep"?: (HelixDonutChart["sweep"]) | 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"?: (HelixDonutChart["data"]) | undefined;
 
   /** Set the innerHTML of the element */
   innerHTML?: (string) | undefined;
@@ -16074,6 +16360,29 @@ no order in it. */
 Set it to start with cells selected. Written by a press or a key under
 `selection-mode`. */
   value?: (HelixHeatmap["value"]) | 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?: (HelixHeatmap["data"]) | undefined;
 
   /** Fired once a press or a key has changed which cells are selected. */
   onchange?: ((e: HelixHeatmapElementEvent) => void) | undefined;
@@ -16257,6 +16566,29 @@ no order in it. */
 Set it to start with cells selected. Written by a press or a key under
 `selection-mode`. */
   "prop:value"?: (HelixHeatmap["value"]) | 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"?: (HelixHeatmap["data"]) | undefined;
   /** Fired once a press or a key has changed which cells are selected. */
   "on:change"?: ((e: HelixHeatmapElementEvent) => void) | undefined;
   /** Fired before a press or a key changes which cells are selected, with the `value` it would leave. Cancelable. */
@@ -18352,6 +18684,25 @@ chart and a card mean the same thing by the word.
 material choice, it is an absent series, and a chart says that by not
 having the datum rather than by painting it invisibly. */
   material?: (HelixLineChart["material"]) | undefined;
+  /** The words shown in place of the drawing when the table has no readings,
+and the fallback of the `empty` slot. */
+  "empty-text"?: (HelixLineChart["emptyText"]) | undefined;
+  /** The words shown in place of the drawing when the table has no readings,
+and the fallback of the `empty` slot. */
+  emptyText?: (HelixLineChart["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?: (HelixLineChart["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"?: (HelixLineChart["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?: (HelixLineChart["loadingText"]) | undefined;
   /** The id of the table to read.
 
 Names a table in the same tree, so a chart inside another component's
@@ -18509,6 +18860,29 @@ 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?: (HelixLineChart["zero"]) | 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?: (HelixLineChart["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"?: ((
@@ -18561,6 +18935,25 @@ chart and a card mean the same thing by the word.
 material choice, it is an absent series, and a chart says that by not
 having the datum rather than by painting it invisibly. */
   "prop:material"?: (HelixLineChart["material"]) | 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"?: (HelixLineChart["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"?: (HelixLineChart["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"?: (HelixLineChart["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"?: (HelixLineChart["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"?: (HelixLineChart["loadingText"]) | undefined;
   /** The id of the table to read.
 
 Names a table in the same tree, so a chart inside another component's
@@ -18718,6 +19111,29 @@ 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"?: (HelixLineChart["zero"]) | 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"?: (HelixLineChart["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: HelixLineChartHelixReadingChangeElementEvent,
@@ -23911,7 +24327,13 @@ the state's word.
 
 Off by default, because the name and the busy state already change with
 the state, and an orb beside a stream of messages would otherwise talk
-over them. Set it on an orb that is the only sign of progress on the page. */
+over them. Set it on an orb that is the only sign of progress on the page.
+
+**Without it, finishing is silent.** `done` turns the orb into an image
+named "Done" that is no longer busy, which a screen reader reports when it
+next reaches the orb and does not say as it happens. A page whose own
+result arrives in a live region, such as a chat reply, already says the
+work is done; one that shows nothing else sets `announce`. */
   announce?: (HelixOrb["announce"]) | undefined;
   /** The name read by screen readers. Defaults to the name of the state, such
 as "Thinking".
@@ -23971,7 +24393,13 @@ the state's word.
 
 Off by default, because the name and the busy state already change with
 the state, and an orb beside a stream of messages would otherwise talk
-over them. Set it on an orb that is the only sign of progress on the page. */
+over them. Set it on an orb that is the only sign of progress on the page.
+
+**Without it, finishing is silent.** `done` turns the orb into an image
+named "Done" that is no longer busy, which a screen reader reports when it
+next reaches the orb and does not say as it happens. A page whose own
+result arrives in a live region, such as a chat reply, already says the
+work is done; one that shows nothing else sets `announce`. */
   "prop:announce"?: (HelixOrb["announce"]) | undefined;
   /** The name read by screen readers. Defaults to the name of the state, such
 as "Thinking".
@@ -25145,7 +25573,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"?: (HelixProgress["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
@@ -25157,7 +25586,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?: (HelixProgress["formatOptions"]) | undefined;
   /** Whether the length of the task is unknown. The bar then shows activity
 without a value.
@@ -25289,7 +25719,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"?: (HelixProgress["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
@@ -25301,7 +25732,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"?: (HelixProgress["formatOptions"]) | undefined;
   /** Whether the length of the task is unknown. The bar then shows activity
 without a value.
@@ -27277,6 +27709,25 @@ export type HelixScatterChartHelixReadingPressElementEvent =
   HelixScatterChartElementEvent<HelixReadingPressEvent>;
 
 export type HelixScatterChartProps = {
+  /** The words shown in place of the drawing when the table has no readings,
+and the fallback of the `empty` slot. */
+  "empty-text"?: (HelixScatterChart["emptyText"]) | undefined;
+  /** The words shown in place of the drawing when the table has no readings,
+and the fallback of the `empty` slot. */
+  emptyText?: (HelixScatterChart["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?: (HelixScatterChart["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"?: (HelixScatterChart["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?: (HelixScatterChart["loadingText"]) | undefined;
   /** The id of the table to read.
 
 Names a table in the same tree, so a chart inside another component's
@@ -27372,6 +27823,29 @@ 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?: (HelixScatterChart["trend"]) | 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?: (HelixScatterChart["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"?: ((
@@ -27384,6 +27858,25 @@ gives each series' correlation, which says how near the points are to it. */
 };
 
 export type HelixScatterChartSolidJsProps = {
+  /** The words shown in place of the drawing when the table has no readings,
+and the fallback of the `empty` slot. */
+  "attr:empty-text"?: (HelixScatterChart["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"?: (HelixScatterChart["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"?: (HelixScatterChart["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"?: (HelixScatterChart["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"?: (HelixScatterChart["loadingText"]) | undefined;
   /** The id of the table to read.
 
 Names a table in the same tree, so a chart inside another component's
@@ -27479,6 +27972,29 @@ 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"?: (HelixScatterChart["trend"]) | 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"?: (HelixScatterChart["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: HelixScatterChartHelixReadingChangeElementEvent,
@@ -37565,6 +38081,16 @@ export type CustomElements = {
    *
    * Component attributes and properties that can be applied to the element or by using JavaScript.
    *
+   * - `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
@@ -37637,6 +38163,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
@@ -37653,6 +38201,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
@@ -37699,6 +38250,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.
@@ -37755,12 +38313,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.
@@ -38449,6 +39009,16 @@ export type CustomElements = {
    * every component in the library and mean something on one. `wash` because
    * that is what the tier below already calls it, in `--chart-bar-wash` and in
    * the `bar-wash-start` and `bar-wash-end` stops.
+   * - `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
@@ -38580,6 +39150,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
@@ -38596,6 +39188,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
@@ -38642,6 +39237,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.
@@ -38705,6 +39307,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`.
@@ -38712,6 +39315,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.
@@ -38750,10 +39354,31 @@ export type CustomElements = {
    * set the passage apart. `marks` draws one large opening mark over the passage,
    * as a pull quote sets it, in the element's language.
    *
+   * `text-align` sets the passage and its attribution in the middle of the
+   * column or against its far edge, as a pull quote often stands. There, the
+   * mark `marks` draws stands over the passage rather than beside it.
+   * `text-wrap="balance"` evens out a short passage's lines.
+   *
    * ## Attributes & Properties
    *
    * Component attributes and properties that can be applied to the element or by using JavaScript.
    *
+   * - `text-align`/`textAlign`: How the passage and its attribution align, set as `text-align`.
+   *
+   * `center` for a pull quote in the middle of a column and `end` for one
+   * against its far edge. Under either, the mark `marks` draws stands over
+   * the first line. Absent aligns as the prose around it does.
+   *
+   * Named for the CSS property it sets, as `Text.textAlign` is: `align` alone
+   * is a legacy HTML attribute the browser maps to `text-align` by itself,
+   * and it has no `start` or `end`.
+   * - `text-wrap`/`textWrap`: How the passage's lines break, set as `text-wrap`.
+   *
+   * `balance` evens out the length of every line, which suits a pull quote of
+   * a few lines in display type. `pretty` avoids a last line of one short
+   * word, for a longer passage. Absent, the lines break as the browser breaks
+   * them. The same name and values `Text` takes, but `nowrap`, a passage being
+   * more than one line.
    * - `attribution`: Who said it, and where, as words, such as "Maria Lopez, operations
    * manager". The `attribution` slot replaces them, for markup such as a link.
    *
@@ -45340,6 +45965,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
@@ -45356,6 +46003,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
@@ -47823,6 +48473,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
@@ -47839,6 +48511,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
@@ -49526,6 +50201,16 @@ export type CustomElements = {
    * **`transparent` is where this one stops.** A mark with no ink is not a
    * material choice, it is an absent series, and a chart says that by not
    * having the datum rather than by painting it invisibly.
+   * - `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
@@ -49662,6 +50347,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
@@ -49678,6 +50385,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
@@ -49724,6 +50434,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.
@@ -49788,6 +50505,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.
@@ -49795,6 +50513,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`.
@@ -53861,6 +54580,12 @@ export type CustomElements = {
    * Off by default, because the name and the busy state already change with
    * the state, and an orb beside a stream of messages would otherwise talk
    * over them. Set it on an orb that is the only sign of progress on the page.
+   *
+   * **Without it, finishing is silent.** `done` turns the orb into an image
+   * named "Done" that is no longer busy, which a screen reader reports when it
+   * next reaches the orb and does not say as it happens. A page whose own
+   * result arrives in a live region, such as a chat reply, already says the
+   * work is done; one that shows nothing else sets `announce`.
    * - `label`: The name read by screen readers. Defaults to the name of the state, such
    * as "Thinking".
    *
@@ -54981,7 +55706,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.
    *
@@ -55070,6 +55796,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. The bar grows to their height, and over the fill they take the fill's own ink.
    * - `label`: A visible label, above a bar and under a ring. Its words name it in place of `label`.
    *
    * ## CSS Custom Properties
@@ -55077,6 +55804,9 @@ export type CustomElements = {
    * CSS variables available for styling the component.
    *
    * - `--progress-color`: Fill of the part that is done.
+   * - `--progress-content-color`: The color of the words of the default slot where they are over the track, and in a ring.
+   * - `--progress-content-fill-color`: The color of the words of the default slot where they are over the fill.
+   * - `--progress-content-size`: The type size of the words of the default slot.
    * - `--progress-label-color`: Color of a slotted label.
    * - `--progress-label-gap`: Space between a slotted label and the bar.
    * - `--progress-label-size`: Type size of a slotted label.
@@ -55095,6 +55825,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.
@@ -55106,6 +55837,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-progress": Partial<
@@ -56687,6 +57419,16 @@ export type CustomElements = {
    *
    * Component attributes and properties that can be applied to the element or by using JavaScript.
    *
+   * - `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
@@ -56748,6 +57490,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
@@ -56764,6 +57528,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
@@ -56810,6 +57577,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.
@@ -56868,8 +57642,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.
@@ -64966,6 +65742,16 @@ export type CustomElementsSolidJs = {
    *
    * Component attributes and properties that can be applied to the element or by using JavaScript.
    *
+   * - `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
@@ -65038,6 +65824,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
@@ -65054,6 +65862,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
@@ -65100,6 +65911,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.
@@ -65156,12 +65974,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.
@@ -65866,6 +66686,16 @@ export type CustomElementsSolidJs = {
    * every component in the library and mean something on one. `wash` because
    * that is what the tier below already calls it, in `--chart-bar-wash` and in
    * the `bar-wash-start` and `bar-wash-end` stops.
+   * - `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
@@ -65997,6 +66827,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
@@ -66013,6 +66865,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
@@ -66059,6 +66914,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.
@@ -66122,6 +66984,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`.
@@ -66129,6 +66992,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.
@@ -66170,10 +67034,31 @@ export type CustomElementsSolidJs = {
    * set the passage apart. `marks` draws one large opening mark over the passage,
    * as a pull quote sets it, in the element's language.
    *
+   * `text-align` sets the passage and its attribution in the middle of the
+   * column or against its far edge, as a pull quote often stands. There, the
+   * mark `marks` draws stands over the passage rather than beside it.
+   * `text-wrap="balance"` evens out a short passage's lines.
+   *
    * ## Attributes & Properties
    *
    * Component attributes and properties that can be applied to the element or by using JavaScript.
    *
+   * - `text-align`/`textAlign`: How the passage and its attribution align, set as `text-align`.
+   *
+   * `center` for a pull quote in the middle of a column and `end` for one
+   * against its far edge. Under either, the mark `marks` draws stands over
+   * the first line. Absent aligns as the prose around it does.
+   *
+   * Named for the CSS property it sets, as `Text.textAlign` is: `align` alone
+   * is a legacy HTML attribute the browser maps to `text-align` by itself,
+   * and it has no `start` or `end`.
+   * - `text-wrap`/`textWrap`: How the passage's lines break, set as `text-wrap`.
+   *
+   * `balance` evens out the length of every line, which suits a pull quote of
+   * a few lines in display type. `pretty` avoids a last line of one short
+   * word, for a longer passage. Absent, the lines break as the browser breaks
+   * them. The same name and values `Text` takes, but `nowrap`, a passage being
+   * more than one line.
    * - `attribution`: Who said it, and where, as words, such as "Maria Lopez, operations
    * manager". The `attribution` slot replaces them, for markup such as a link.
    *
@@ -72845,6 +73730,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
@@ -72861,6 +73768,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
@@ -75375,6 +76285,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
@@ -75391,6 +76323,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
@@ -77107,6 +78042,16 @@ export type CustomElementsSolidJs = {
    * **`transparent` is where this one stops.** A mark with no ink is not a
    * material choice, it is an absent series, and a chart says that by not
    * having the datum rather than by painting it invisibly.
+   * - `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
@@ -77243,6 +78188,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
@@ -77259,6 +78226,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
@@ -77305,6 +78275,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.
@@ -77369,6 +78346,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.
@@ -77376,6 +78354,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`.
@@ -81531,6 +82510,12 @@ export type CustomElementsSolidJs = {
    * Off by default, because the name and the busy state already change with
    * the state, and an orb beside a stream of messages would otherwise talk
    * over them. Set it on an orb that is the only sign of progress on the page.
+   *
+   * **Without it, finishing is silent.** `done` turns the orb into an image
+   * named "Done" that is no longer busy, which a screen reader reports when it
+   * next reaches the orb and does not say as it happens. A page whose own
+   * result arrives in a live region, such as a chat reply, already says the
+   * work is done; one that shows nothing else sets `announce`.
    * - `label`: The name read by screen readers. Defaults to the name of the state, such
    * as "Thinking".
    *
@@ -82671,7 +83656,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.
    *
@@ -82760,6 +83746,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. The bar grows to their height, and over the fill they take the fill's own ink.
    * - `label`: A visible label, above a bar and under a ring. Its words name it in place of `label`.
    *
    * ## CSS Custom Properties
@@ -82767,6 +83754,9 @@ export type CustomElementsSolidJs = {
    * CSS variables available for styling the component.
    *
    * - `--progress-color`: Fill of the part that is done.
+   * - `--progress-content-color`: The color of the words of the default slot where they are over the track, and in a ring.
+   * - `--progress-content-fill-color`: The color of the words of the default slot where they are over the fill.
+   * - `--progress-content-size`: The type size of the words of the default slot.
    * - `--progress-label-color`: Color of a slotted label.
    * - `--progress-label-gap`: Space between a slotted label and the bar.
    * - `--progress-label-size`: Type size of a slotted label.
@@ -82785,6 +83775,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.
@@ -82796,6 +83787,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-progress": Partial<
@@ -84417,6 +85409,16 @@ export type CustomElementsSolidJs = {
    *
    * Component attributes and properties that can be applied to the element or by using JavaScript.
    *
+   * - `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
@@ -84478,6 +85480,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
@@ -84494,6 +85518,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
@@ -84540,6 +85567,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.
@@ -84598,8 +85632,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.
@@ -93818,6 +94854,12 @@ export type CustomCssProperties = {
   "--popover-shadow"?: (string) | undefined;
   /** Fill of the part that is done. */
   "--progress-color"?: (string) | undefined;
+  /** The color of the words of the default slot where they are over the track, and in a ring. */
+  "--progress-content-color"?: (string) | undefined;
+  /** The color of the words of the default slot where they are over the fill. */
+  "--progress-content-fill-color"?: (string) | undefined;
+  /** The type size of the words of the default slot. */
+  "--progress-content-size"?: (string) | undefined;
   /** Color of a slotted label. */
   "--progress-label-color"?: (string) | undefined;
   /** Space between a slotted label and the bar. */