@fusion.dev/helix-headless 0.5.0 → 0.7.0

package/types/jsx.d.ts

@@ -3838,6 +3838,20 @@ export type HelixHeadlessDataTableProps = {
   "default-sort"?: (HelixHeadlessDataTable["defaultSort"]) | undefined;
   /** Order to open on, where nothing declared one. */
   defaultSort?: (HelixHeadlessDataTable["defaultSort"]) | undefined;
+  /** How tall a row is taken to be before it has been drawn, in pixels.
+
+Only read while `windowed`, and a starting guess rather than a claim: a
+cell that wraps makes its row taller than its neighbors, and the window
+replaces this with what each row came to as it draws. It still has to be
+close, because it is what the scrollbar is built from before anything has
+been measured. */
+  estimate?: (HelixHeadlessDataTable["estimate"]) | undefined;
+  /** The order, as `field:direction`.
+
+Set it and this element defers: a reader's click fires `helix-sort` and
+changes nothing until a new value arrives. `default-sort` seeds an order this
+element then owns. */
+  sort?: (HelixHeadlessDataTable["sort"]) | undefined;
   /** The field naming a row's stable identity.
 
 **Needed before selection exists, not after.** Lit keys the rendered rows by
@@ -3847,20 +3861,20 @@ attached to the row it belongs to. Left unset the index is the key, which is
 correct only while nothing reorders: it is why this defaults to something
 that works and is worth setting anyway. */
   key?: (HelixHeadlessDataTable["key"]) | undefined;
-  /** The order, as `field:direction`.
-
-Set it and this element defers: a reader's click fires `helix-sort` and
-changes nothing until a new value arrives. `default-sort` seeds an order this
-element then owns. */
-  sort?: (HelixHeadlessDataTable["sort"]) | undefined;
-  /** Accessible name for the grid. */
-  label?: (HelixHeadlessDataTable["label"]) | undefined;
   /** What the rows are narrowed to, as one query across every column.
 
 One query rather than a predicate per column, which is what a reader means
 by a search box above a table. It matches on each column's ordering value,
 so search and sort cannot disagree about what a column holds. */
   filter?: (HelixHeadlessDataTable["filter"]) | undefined;
+  /** Accessible name for the grid. */
+  label?: (HelixHeadlessDataTable["label"]) | undefined;
+  /** The page on show, from 1.
+
+Clamped on the way out, so what this reports is the page it drew: a
+bookmarked link to page 99 of a result that has since shrunk reads back as
+the last page rather than as 99. */
+  page?: (HelixHeadlessDataTable["page"]) | undefined;
   /** Whether this element does the work or asks the consumer to.
 
 `client` filters, sorts and pages `rows` itself. `server` applies none of
@@ -3870,12 +3884,6 @@ the client cannot hold the data, so this is not an optimization, it is the
 only mode that works, and it is here from the start because adding it later
 inverts the data flow. */
   mode?: (HelixHeadlessDataTable["mode"]) | undefined;
-  /** The page on show, from 1.
-
-Clamped on the way out, so what this reports is the page it drew: a
-bookmarked link to page 99 of a result that has since shrunk reads back as
-the last page rather than as 99. */
-  page?: (HelixHeadlessDataTable["page"]) | undefined;
   /** How many rows a page holds. Zero is every row, which is what "no paging" means.
 
 **It announces nothing, and that is not an omission.** Nothing in this
@@ -3899,6 +3907,24 @@ nothing about the result. Ignored in `client` mode rather than trusted,
 because two sources for one count is the mistake, and here the array is the
 one that cannot be stale. */
   total?: (HelixHeadlessDataTable["total"]) | undefined;
+  /** Draws the rows in view and stands empty space in for the rest.
+
+**Not a `mode`.** `mode` says where the rows come from and who filtered
+them; this says how many of the ones we hold get drawn. They are
+independent: a consumer fetching five thousand rows a chunk at a time wants
+`mode="server"` and this at once, and folding this into `mode` would be an
+API that forbids that combination for no reason.
+
+**Composes with `paginated` rather than excluding it.** A window over a
+page is coherent -- the page is the slice of the result, the window is the
+part of that slice on screen -- and the arithmetic is the same either way,
+so there is nothing to forbid. Together they suit a table paging at a
+thousand rows, where the page is a reasonable fetch and a poor render.
+
+Off by default. Windowing costs a scroll listener, a measurement per row
+drawn, and a `block-size` on the scrolling box, and a table of twenty rows
+should pay none of them. */
+  windowed?: (HelixHeadlessDataTable["windowed"]) | undefined;
   /** Whether to draw a pagination under the grid.
 
 On by default once a page size is set, because a paged table with no way to
@@ -3958,6 +3984,20 @@ export type HelixHeadlessDataTableSolidJsProps = {
   "attr:default-sort"?: (HelixHeadlessDataTable["defaultSort"]) | undefined;
   /** Order to open on, where nothing declared one. */
   "prop:defaultSort"?: (HelixHeadlessDataTable["defaultSort"]) | undefined;
+  /** How tall a row is taken to be before it has been drawn, in pixels.
+
+Only read while `windowed`, and a starting guess rather than a claim: a
+cell that wraps makes its row taller than its neighbors, and the window
+replaces this with what each row came to as it draws. It still has to be
+close, because it is what the scrollbar is built from before anything has
+been measured. */
+  "prop:estimate"?: (HelixHeadlessDataTable["estimate"]) | undefined;
+  /** The order, as `field:direction`.
+
+Set it and this element defers: a reader's click fires `helix-sort` and
+changes nothing until a new value arrives. `default-sort` seeds an order this
+element then owns. */
+  "prop:sort"?: (HelixHeadlessDataTable["sort"]) | undefined;
   /** The field naming a row's stable identity.
 
 **Needed before selection exists, not after.** Lit keys the rendered rows by
@@ -3967,20 +4007,20 @@ attached to the row it belongs to. Left unset the index is the key, which is
 correct only while nothing reorders: it is why this defaults to something
 that works and is worth setting anyway. */
   "prop:key"?: (HelixHeadlessDataTable["key"]) | undefined;
-  /** The order, as `field:direction`.
-
-Set it and this element defers: a reader's click fires `helix-sort` and
-changes nothing until a new value arrives. `default-sort` seeds an order this
-element then owns. */
-  "prop:sort"?: (HelixHeadlessDataTable["sort"]) | undefined;
-  /** Accessible name for the grid. */
-  "prop:label"?: (HelixHeadlessDataTable["label"]) | undefined;
   /** What the rows are narrowed to, as one query across every column.
 
 One query rather than a predicate per column, which is what a reader means
 by a search box above a table. It matches on each column's ordering value,
 so search and sort cannot disagree about what a column holds. */
   "prop:filter"?: (HelixHeadlessDataTable["filter"]) | undefined;
+  /** Accessible name for the grid. */
+  "prop:label"?: (HelixHeadlessDataTable["label"]) | undefined;
+  /** The page on show, from 1.
+
+Clamped on the way out, so what this reports is the page it drew: a
+bookmarked link to page 99 of a result that has since shrunk reads back as
+the last page rather than as 99. */
+  "prop:page"?: (HelixHeadlessDataTable["page"]) | undefined;
   /** Whether this element does the work or asks the consumer to.
 
 `client` filters, sorts and pages `rows` itself. `server` applies none of
@@ -3990,12 +4030,6 @@ the client cannot hold the data, so this is not an optimization, it is the
 only mode that works, and it is here from the start because adding it later
 inverts the data flow. */
   "prop:mode"?: (HelixHeadlessDataTable["mode"]) | undefined;
-  /** The page on show, from 1.
-
-Clamped on the way out, so what this reports is the page it drew: a
-bookmarked link to page 99 of a result that has since shrunk reads back as
-the last page rather than as 99. */
-  "prop:page"?: (HelixHeadlessDataTable["page"]) | undefined;
   /** How many rows a page holds. Zero is every row, which is what "no paging" means.
 
 **It announces nothing, and that is not an omission.** Nothing in this
@@ -4019,6 +4053,24 @@ nothing about the result. Ignored in `client` mode rather than trusted,
 because two sources for one count is the mistake, and here the array is the
 one that cannot be stale. */
   "prop:total"?: (HelixHeadlessDataTable["total"]) | undefined;
+  /** Draws the rows in view and stands empty space in for the rest.
+
+**Not a `mode`.** `mode` says where the rows come from and who filtered
+them; this says how many of the ones we hold get drawn. They are
+independent: a consumer fetching five thousand rows a chunk at a time wants
+`mode="server"` and this at once, and folding this into `mode` would be an
+API that forbids that combination for no reason.
+
+**Composes with `paginated` rather than excluding it.** A window over a
+page is coherent -- the page is the slice of the result, the window is the
+part of that slice on screen -- and the arithmetic is the same either way,
+so there is nothing to forbid. Together they suit a table paging at a
+thousand rows, where the page is a reasonable fetch and a poor render.
+
+Off by default. Windowing costs a scroll listener, a measurement per row
+drawn, and a `block-size` on the scrolling box, and a table of twenty rows
+should pay none of them. */
+  "prop:windowed"?: (HelixHeadlessDataTable["windowed"]) | undefined;
   /** Whether to draw a pagination under the grid.
 
 On by default once a page size is set, because a paged table with no way to
@@ -15296,21 +15348,43 @@ past the end is the one write the platform answers with an exception. */
 };
 
 export type HelixHeadlessVirtualListProps = {
-  /** How tall one row is, in pixels, used to map scroll offset to an index. */
+  /** How tall one row is, in pixels, used to map scroll offset to an index.
+
+An estimate rather than a measurement while `measured` is off, which is
+right whenever the rows really are one height and is the cheaper of the two. */
   estimate?: (HelixHeadlessVirtualList["estimate"]) | undefined;
   /** Id of the element holding the rows, as JSON in a script. */
   for?: (HelixHeadlessVirtualList["for"]) | undefined;
   /** What the list is called, since the rendered rows are only a window on it. */
   label?: (HelixHeadlessVirtualList["label"]) | undefined;
+  /** Places rows by what they came to rather than by `estimate`.
+
+**Off by default, because the straight line is better when it holds.** One
+estimate makes offset and index convert by division, which can never
+disagree with itself; measuring is what a set of genuinely different
+heights needs and costs a read of each row as it renders. A list of
+one-line rows should leave this alone. */
+  measured?: (HelixHeadlessVirtualList["measured"]) | undefined;
 };
 
 export type HelixHeadlessVirtualListSolidJsProps = {
-  /** How tall one row is, in pixels, used to map scroll offset to an index. */
+  /** How tall one row is, in pixels, used to map scroll offset to an index.
+
+An estimate rather than a measurement while `measured` is off, which is
+right whenever the rows really are one height and is the cheaper of the two. */
   "prop:estimate"?: (HelixHeadlessVirtualList["estimate"]) | undefined;
   /** Id of the element holding the rows, as JSON in a script. */
   "prop:for"?: (HelixHeadlessVirtualList["for"]) | undefined;
   /** What the list is called, since the rendered rows are only a window on it. */
   "prop:label"?: (HelixHeadlessVirtualList["label"]) | undefined;
+  /** Places rows by what they came to rather than by `estimate`.
+
+**Off by default, because the straight line is better when it holds.** One
+estimate makes offset and index convert by division, which can never
+disagree with itself; measuring is what a set of genuinely different
+heights needs and costs a read of each row as it renders. A list of
+one-line rows should leave this alone. */
+  "prop:measured"?: (HelixHeadlessVirtualList["measured"]) | undefined;
 
   /** Set the innerHTML of the element */
   innerHTML?: (string) | undefined;
@@ -18736,6 +18810,18 @@ export type CustomElements = {
    * - `default-page`/`defaultPage`: Page to open on, where nothing declared one.
    * - `default-page-size`/`defaultPageSize`: Page size to open with, where nothing declared one.
    * - `default-sort`/`defaultSort`: Order to open on, where nothing declared one.
+   * - `estimate`: How tall a row is taken to be before it has been drawn, in pixels.
+   *
+   * Only read while `windowed`, and a starting guess rather than a claim: a
+   * cell that wraps makes its row taller than its neighbors, and the window
+   * replaces this with what each row came to as it draws. It still has to be
+   * close, because it is what the scrollbar is built from before anything has
+   * been measured.
+   * - `sort`: The order, as `field:direction`.
+   *
+   * Set it and this element defers: a reader's click fires `helix-sort` and
+   * changes nothing until a new value arrives. `default-sort` seeds an order this
+   * element then owns.
    * - `key`: The field naming a row's stable identity.
    *
    * **Needed before selection exists, not after.** Lit keys the rendered rows by
@@ -18744,17 +18830,17 @@ export type CustomElements = {
    * attached to the row it belongs to. Left unset the index is the key, which is
    * correct only while nothing reorders: it is why this defaults to something
    * that works and is worth setting anyway.
-   * - `sort`: The order, as `field:direction`.
-   *
-   * Set it and this element defers: a reader's click fires `helix-sort` and
-   * changes nothing until a new value arrives. `default-sort` seeds an order this
-   * element then owns.
-   * - `label`: Accessible name for the grid.
    * - `filter`: What the rows are narrowed to, as one query across every column.
    *
    * One query rather than a predicate per column, which is what a reader means
    * by a search box above a table. It matches on each column's ordering value,
    * so search and sort cannot disagree about what a column holds.
+   * - `label`: Accessible name for the grid.
+   * - `page`: The page on show, from 1.
+   *
+   * Clamped on the way out, so what this reports is the page it drew: a
+   * bookmarked link to page 99 of a result that has since shrunk reads back as
+   * the last page rather than as 99.
    * - `mode`: Whether this element does the work or asks the consumer to.
    *
    * `client` filters, sorts and pages `rows` itself. `server` applies none of
@@ -18763,11 +18849,6 @@ export type CustomElements = {
    * the client cannot hold the data, so this is not an optimization, it is the
    * only mode that works, and it is here from the start because adding it later
    * inverts the data flow.
-   * - `page`: The page on show, from 1.
-   *
-   * Clamped on the way out, so what this reports is the page it drew: a
-   * bookmarked link to page 99 of a result that has since shrunk reads back as
-   * the last page rather than as 99.
    * - `page-size`/`pageSize`: How many rows a page holds. Zero is every row, which is what "no paging" means.
    *
    * **It announces nothing, and that is not an omission.** Nothing in this
@@ -18781,6 +18862,23 @@ export type CustomElements = {
    * nothing about the result. Ignored in `client` mode rather than trusted,
    * because two sources for one count is the mistake, and here the array is the
    * one that cannot be stale.
+   * - `windowed`: Draws the rows in view and stands empty space in for the rest.
+   *
+   * **Not a `mode`.** `mode` says where the rows come from and who filtered
+   * them; this says how many of the ones we hold get drawn. They are
+   * independent: a consumer fetching five thousand rows a chunk at a time wants
+   * `mode="server"` and this at once, and folding this into `mode` would be an
+   * API that forbids that combination for no reason.
+   *
+   * **Composes with `paginated` rather than excluding it.** A window over a
+   * page is coherent -- the page is the slice of the result, the window is the
+   * part of that slice on screen -- and the arithmetic is the same either way,
+   * so there is nothing to forbid. Together they suit a table paging at a
+   * thousand rows, where the page is a reasonable fetch and a poor render.
+   *
+   * Off by default. Windowing costs a scroll listener, a measurement per row
+   * drawn, and a `block-size` on the scrolling box, and a table of twenty rows
+   * should pay none of them.
    * - `paginated`: Whether to draw a pagination under the grid.
    *
    * On by default once a page size is set, because a paged table with no way to
@@ -18863,6 +18961,8 @@ export type CustomElements = {
    *
    * Custom selectors for styling elements within the component.
    *
+   * - `after`: The room the rows below the window would have taken. Windowed only.
+   * - `before`: The room the rows above the window would have taken. Windowed only.
    * - `cell`: One cell.
    * - `empty`: Shown when no rows match.
    * - `footer`: The region below the grid.
@@ -29423,8 +29523,18 @@ export type CustomElements = {
    * Component attributes and properties that can be applied to the element or by using JavaScript.
    *
    * - `estimate`: How tall one row is, in pixels, used to map scroll offset to an index.
+   *
+   * An estimate rather than a measurement while `measured` is off, which is
+   * right whenever the rows really are one height and is the cheaper of the two.
    * - `for`: Id of the element holding the rows, as JSON in a script.
    * - `label`: What the list is called, since the rendered rows are only a window on it.
+   * - `measured`: Places rows by what they came to rather than by `estimate`.
+   *
+   * **Off by default, because the straight line is better when it holds.** One
+   * estimate makes offset and index convert by division, which can never
+   * disagree with itself; measuring is what a set of genuinely different
+   * heights needs and costs a read of each row as it renders. A list of
+   * one-line rows should leave this alone.
    * - `whenSettled`: Resolves a frame after the first update, when transitions are switched on.
    *
    * **Named `whenSettled` because `settled` is taken four times over**, by
@@ -32935,6 +33045,18 @@ export type CustomElementsSolidJs = {
    * - `default-page`/`defaultPage`: Page to open on, where nothing declared one.
    * - `default-page-size`/`defaultPageSize`: Page size to open with, where nothing declared one.
    * - `default-sort`/`defaultSort`: Order to open on, where nothing declared one.
+   * - `estimate`: How tall a row is taken to be before it has been drawn, in pixels.
+   *
+   * Only read while `windowed`, and a starting guess rather than a claim: a
+   * cell that wraps makes its row taller than its neighbors, and the window
+   * replaces this with what each row came to as it draws. It still has to be
+   * close, because it is what the scrollbar is built from before anything has
+   * been measured.
+   * - `sort`: The order, as `field:direction`.
+   *
+   * Set it and this element defers: a reader's click fires `helix-sort` and
+   * changes nothing until a new value arrives. `default-sort` seeds an order this
+   * element then owns.
    * - `key`: The field naming a row's stable identity.
    *
    * **Needed before selection exists, not after.** Lit keys the rendered rows by
@@ -32943,17 +33065,17 @@ export type CustomElementsSolidJs = {
    * attached to the row it belongs to. Left unset the index is the key, which is
    * correct only while nothing reorders: it is why this defaults to something
    * that works and is worth setting anyway.
-   * - `sort`: The order, as `field:direction`.
-   *
-   * Set it and this element defers: a reader's click fires `helix-sort` and
-   * changes nothing until a new value arrives. `default-sort` seeds an order this
-   * element then owns.
-   * - `label`: Accessible name for the grid.
    * - `filter`: What the rows are narrowed to, as one query across every column.
    *
    * One query rather than a predicate per column, which is what a reader means
    * by a search box above a table. It matches on each column's ordering value,
    * so search and sort cannot disagree about what a column holds.
+   * - `label`: Accessible name for the grid.
+   * - `page`: The page on show, from 1.
+   *
+   * Clamped on the way out, so what this reports is the page it drew: a
+   * bookmarked link to page 99 of a result that has since shrunk reads back as
+   * the last page rather than as 99.
    * - `mode`: Whether this element does the work or asks the consumer to.
    *
    * `client` filters, sorts and pages `rows` itself. `server` applies none of
@@ -32962,11 +33084,6 @@ export type CustomElementsSolidJs = {
    * the client cannot hold the data, so this is not an optimization, it is the
    * only mode that works, and it is here from the start because adding it later
    * inverts the data flow.
-   * - `page`: The page on show, from 1.
-   *
-   * Clamped on the way out, so what this reports is the page it drew: a
-   * bookmarked link to page 99 of a result that has since shrunk reads back as
-   * the last page rather than as 99.
    * - `page-size`/`pageSize`: How many rows a page holds. Zero is every row, which is what "no paging" means.
    *
    * **It announces nothing, and that is not an omission.** Nothing in this
@@ -32980,6 +33097,23 @@ export type CustomElementsSolidJs = {
    * nothing about the result. Ignored in `client` mode rather than trusted,
    * because two sources for one count is the mistake, and here the array is the
    * one that cannot be stale.
+   * - `windowed`: Draws the rows in view and stands empty space in for the rest.
+   *
+   * **Not a `mode`.** `mode` says where the rows come from and who filtered
+   * them; this says how many of the ones we hold get drawn. They are
+   * independent: a consumer fetching five thousand rows a chunk at a time wants
+   * `mode="server"` and this at once, and folding this into `mode` would be an
+   * API that forbids that combination for no reason.
+   *
+   * **Composes with `paginated` rather than excluding it.** A window over a
+   * page is coherent -- the page is the slice of the result, the window is the
+   * part of that slice on screen -- and the arithmetic is the same either way,
+   * so there is nothing to forbid. Together they suit a table paging at a
+   * thousand rows, where the page is a reasonable fetch and a poor render.
+   *
+   * Off by default. Windowing costs a scroll listener, a measurement per row
+   * drawn, and a `block-size` on the scrolling box, and a table of twenty rows
+   * should pay none of them.
    * - `paginated`: Whether to draw a pagination under the grid.
    *
    * On by default once a page size is set, because a paged table with no way to
@@ -33062,6 +33196,8 @@ export type CustomElementsSolidJs = {
    *
    * Custom selectors for styling elements within the component.
    *
+   * - `after`: The room the rows below the window would have taken. Windowed only.
+   * - `before`: The room the rows above the window would have taken. Windowed only.
    * - `cell`: One cell.
    * - `empty`: Shown when no rows match.
    * - `footer`: The region below the grid.
@@ -43837,8 +43973,18 @@ export type CustomElementsSolidJs = {
    * Component attributes and properties that can be applied to the element or by using JavaScript.
    *
    * - `estimate`: How tall one row is, in pixels, used to map scroll offset to an index.
+   *
+   * An estimate rather than a measurement while `measured` is off, which is
+   * right whenever the rows really are one height and is the cheaper of the two.
    * - `for`: Id of the element holding the rows, as JSON in a script.
    * - `label`: What the list is called, since the rendered rows are only a window on it.
+   * - `measured`: Places rows by what they came to rather than by `estimate`.
+   *
+   * **Off by default, because the straight line is better when it holds.** One
+   * estimate makes offset and index convert by division, which can never
+   * disagree with itself; measuring is what a set of genuinely different
+   * heights needs and costs a read of each row as it renders. A list of
+   * one-line rows should leave this alone.
    * - `whenSettled`: Resolves a frame after the first update, when transitions are switched on.
    *
    * **Named `whenSettled` because `settled` is taken four times over**, by

package/types/vue.d.ts

@@ -1985,6 +1985,20 @@ export type HelixHeadlessDataTableVueProps = {
   "default-sort"?: (HelixHeadlessDataTable["defaultSort"]) | undefined;
   /** Order to open on, where nothing declared one. */
   defaultSort?: (HelixHeadlessDataTable["defaultSort"]) | undefined;
+  /** How tall a row is taken to be before it has been drawn, in pixels.
+
+Only read while `windowed`, and a starting guess rather than a claim: a
+cell that wraps makes its row taller than its neighbors, and the window
+replaces this with what each row came to as it draws. It still has to be
+close, because it is what the scrollbar is built from before anything has
+been measured. */
+  estimate?: (HelixHeadlessDataTable["estimate"]) | undefined;
+  /** The order, as `field:direction`.
+
+Set it and this element defers: a reader's click fires `helix-sort` and
+changes nothing until a new value arrives. `default-sort` seeds an order this
+element then owns. */
+  sort?: (HelixHeadlessDataTable["sort"]) | undefined;
   /** The field naming a row's stable identity.
 
 **Needed before selection exists, not after.** Lit keys the rendered rows by
@@ -1994,20 +2008,20 @@ attached to the row it belongs to. Left unset the index is the key, which is
 correct only while nothing reorders: it is why this defaults to something
 that works and is worth setting anyway. */
   key?: (HelixHeadlessDataTable["key"]) | undefined;
-  /** The order, as `field:direction`.
-
-Set it and this element defers: a reader's click fires `helix-sort` and
-changes nothing until a new value arrives. `default-sort` seeds an order this
-element then owns. */
-  sort?: (HelixHeadlessDataTable["sort"]) | undefined;
-  /** Accessible name for the grid. */
-  label?: (HelixHeadlessDataTable["label"]) | undefined;
   /** What the rows are narrowed to, as one query across every column.
 
 One query rather than a predicate per column, which is what a reader means
 by a search box above a table. It matches on each column's ordering value,
 so search and sort cannot disagree about what a column holds. */
   filter?: (HelixHeadlessDataTable["filter"]) | undefined;
+  /** Accessible name for the grid. */
+  label?: (HelixHeadlessDataTable["label"]) | undefined;
+  /** The page on show, from 1.
+
+Clamped on the way out, so what this reports is the page it drew: a
+bookmarked link to page 99 of a result that has since shrunk reads back as
+the last page rather than as 99. */
+  page?: (HelixHeadlessDataTable["page"]) | undefined;
   /** Whether this element does the work or asks the consumer to.
 
 `client` filters, sorts and pages `rows` itself. `server` applies none of
@@ -2017,12 +2031,6 @@ the client cannot hold the data, so this is not an optimization, it is the
 only mode that works, and it is here from the start because adding it later
 inverts the data flow. */
   mode?: (HelixHeadlessDataTable["mode"]) | undefined;
-  /** The page on show, from 1.
-
-Clamped on the way out, so what this reports is the page it drew: a
-bookmarked link to page 99 of a result that has since shrunk reads back as
-the last page rather than as 99. */
-  page?: (HelixHeadlessDataTable["page"]) | undefined;
   /** How many rows a page holds. Zero is every row, which is what "no paging" means.
 
 **It announces nothing, and that is not an omission.** Nothing in this
@@ -2046,6 +2054,24 @@ nothing about the result. Ignored in `client` mode rather than trusted,
 because two sources for one count is the mistake, and here the array is the
 one that cannot be stale. */
   total?: (HelixHeadlessDataTable["total"]) | undefined;
+  /** Draws the rows in view and stands empty space in for the rest.
+
+**Not a `mode`.** `mode` says where the rows come from and who filtered
+them; this says how many of the ones we hold get drawn. They are
+independent: a consumer fetching five thousand rows a chunk at a time wants
+`mode="server"` and this at once, and folding this into `mode` would be an
+API that forbids that combination for no reason.
+
+**Composes with `paginated` rather than excluding it.** A window over a
+page is coherent -- the page is the slice of the result, the window is the
+part of that slice on screen -- and the arithmetic is the same either way,
+so there is nothing to forbid. Together they suit a table paging at a
+thousand rows, where the page is a reasonable fetch and a poor render.
+
+Off by default. Windowing costs a scroll listener, a measurement per row
+drawn, and a `block-size` on the scrolling box, and a table of twenty rows
+should pay none of them. */
+  windowed?: (HelixHeadlessDataTable["windowed"]) | undefined;
   /** Whether to draw a pagination under the grid.
 
 On by default once a page size is set, because a paged table with no way to
@@ -7846,12 +7872,23 @@ export type HelixHeadlessVideoVueEvents = {
 };
 
 export type HelixHeadlessVirtualListVueProps = {
-  /** How tall one row is, in pixels, used to map scroll offset to an index. */
+  /** How tall one row is, in pixels, used to map scroll offset to an index.
+
+An estimate rather than a measurement while `measured` is off, which is
+right whenever the rows really are one height and is the cheaper of the two. */
   estimate?: (HelixHeadlessVirtualList["estimate"]) | undefined;
   /** Id of the element holding the rows, as JSON in a script. */
   for?: (HelixHeadlessVirtualList["for"]) | undefined;
   /** What the list is called, since the rendered rows are only a window on it. */
   label?: (HelixHeadlessVirtualList["label"]) | undefined;
+  /** Places rows by what they came to rather than by `estimate`.
+
+**Off by default, because the straight line is better when it holds.** One
+estimate makes offset and index convert by division, which can never
+disagree with itself; measuring is what a set of genuinely different
+heights needs and costs a read of each row as it renders. A list of
+one-line rows should leave this alone. */
+  measured?: (HelixHeadlessVirtualList["measured"]) | undefined;
 };
 
 export type HelixHeadlessVirtualListVueEvents = {};